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

2013/07/04 22:08
阅读数 1.3K

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

在传统的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)子数组,数组里面每个项是一个字典。

>>> huangz  
{'friends': [{'name': 'peter'}, {'name': 'john'}, {'name': 'marry'}], 'name': 'huangz'}

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

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

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

['name': 'huangz', 'friends_reference_id': [12, 26, 30]] 

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

引用链接

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

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

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

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

>>> # 数据
>>> peter = {'name':'peter'}
>>> marry = {'name':'marry'}
>>> john = {'name':'john'}
>>>
>>> # 插入数据
>>> c.test.people.insert([peter, john, marry])
[ObjectId('4e98075224b7d408dc000004'), ObjectId('4e98075224b7d408dc000005'), ObjectId('4e98075224b7d408dc000006')]
>>>
>>> # 建立huangz文档,以及指向各个朋友的链接
>>> huangz = {'name': 'huangz',
...     'friends': [ DBRef('people', peter['_id']),
...                  DBRef('people', john['_id']),
...                  DBRef('people', marry['_id']) ]}
>>>
>>> c.test.people.insert(huangz)
ObjectId('4e9807d924b7d408dc000007')
>>>
>>> # 查看huangz文档
>>> huangz
{'_id': ObjectId('4e9807d924b7d408dc000007'), 'friends': [DBRef('people', ObjectId('4e98075224b7d408dc000004')), DBRef('people', ObjectId('4e98075224b7d408dc000005')), DBRef('people', ObjectId('4e98075224b7d408dc000006'))], 'name': 'huangz'}
>>>
>>> # 对friends中的所有域进行解引用
>>> [ c.test.dereference(friend) for friend in huangz['friends'] ]
[{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 例子:

>>> from pymongo.connection import Connection
>>> # 自动解引用所需的函数
>>> from pymongo.son_manipulator import AutoReference, NamespaceInjector
>>>
>>> # 连接数据库,并选择 test 数据库作为储存
>>> c = Connection()
>>> db = c.test
>>>
>>> # 魔法发生的地方。。。
>>> db.add_son_manipulator(NamespaceInjector())
>>> db.add_son_manipulator(AutoReference(db))
>>> 
>>> # 数据
>>> peter = {'name': 'peter'}
>>> john = {'name': 'john'}
>>> marry = {'name': 'marry'}
>>>
>>> # 将数据插入数据库
>>> db.people.insert([peter, john, marry])
[ObjectId('4e980fe824b7d41f52000000'), ObjectId('4e980fe824b7d41f52000001'), ObjectId('4e980fe824b7d41f52000002')]
>>>
>>> # huangz 文档
>>> huangz = {'name': 'huangz', 
...           'friends': [peter, john, marry]}
>>> db.people.insert(huangz)
ObjectId('4e98104324b7d41f52000003')
>>>
>>> # 看一看,文档里多了一些奇怪的东西。。。嗯。。。
>>> huangz
{'_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'}
>>> 
>>> # 试试提取 friends 域中的数据(注意这里我们没有手动进行解引用)
>>> huangz['friends'][0]
{'_ns': u'people', '_id': ObjectId('4e980fe824b7d41f52000000'), 'name': 'peter'}
>>>
>>> # wow,解引用自动完成了!再试试
>>> huangz['friends'][0]['name']
'peter'
>>>
>>> # 这里你可能会疑惑,我们是不是使用嵌套将数据放进了huangz文档里面,而实际上没有使用引用?
>>> # 答案是,不是的,我们使用了引用,看看 peter 文档,它有一个id
>>> # 证明 peter 文档是一个独立文档,而不是一个嵌入文档:
>>> peter
{'_ns': u'people', '_id': ObjectId('4e980fe824b7d41f52000000'), 'name': 'peter'}
>>>
>>> # 如果你还是不信,我们可以试试修改 peter 文档,然后再保存
>>> # 看看 huangz 文档里面的 peter,是否会变化
>>> peter['name'] = 'peter Liu'
>>> db.people.save(peter)
ObjectId('4e980fe824b7d41f52000000')
>>>
>>> # 哈,huangz 文档里面的 peter 也发生了变化,证明我们使用的
>>> # 是引用而不是嵌套,嘿,我可是童叟无欺、信誉良好的阿。
>>> huangz['friends'][0]['name']
'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执行解引用的时候,你需要一次额外的查询。

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

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

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

>>> peter = {'name': 'peter'}
>>> john = {'name': 'john'}
>>> marry = {'name': 'marry'}
>>>
>>> huangz = {'name': 'huangz', 'friends': [peter, john, marry]}
>>>
>>> people.insert(huangz)
ObjectId('4e98e30b24b7d40a53000002')
>>>
>>> huangz
{'_id': ObjectId('4e98e30b24b7d40a53000002'), 'friends': [{'name': 'peter'}, {'name': 'john'}, {'name': 'marry'}], 'name': 'huangz'}

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

>>> people.find_one({'_id': huangz['_id']})
{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 数据域都放在一起,所以,执行这个文档只需要一次数据库查询,嗯,就是这样。

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

>>> peter = {'name': 'peter'}
>>> john = {'name': 'john'}
>>> marry = {'name': 'marry'}
>>>
>>> people.insert([peter, john, marry])
[ObjectId('4e98e41b24b7d40a53000003'), ObjectId('4e98e41b24b7d40a53000004'), ObjectId('4e98e41b24b7d40a53000005')]
>>>
>>> huangz = {'name': 'huangz',
...           'friends': [ DBRef('people', peter['_id']),
...                        DBRef('people', john['_id']),
...                        DBRef('people', marry['_id']) ] }
>>> people.insert(huangz)
ObjectId('4e98e4da24b7d40a53000006')

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

>>> people.find_one({'_id': huangz['_id']})
{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 文档进行解引用:

>>> for friend in huangz['friends']:
...     db.dereference(friend)
... 
{u'_id': ObjectId('4e98e41b24b7d40a53000003'), u'name': u'peter'}
{u'_id': ObjectId('4e98e41b24b7d40a53000004'), u'name': u'john'}
{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 条数据都被浪费了)。

data = weibo.find_one({'name': 'huangz'})

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

data = weibo.find_one({'name': 'huangz'}, {'message': {'$slice': -100}})

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

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

data = weibo.find_one({'name': 'huangz'}, {'message: 0})

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

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

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

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

---

附录

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

时间关系。。。

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

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

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

嗯,就这样,我们下篇博文再见,bye bye。

---

附录

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

展开阅读全文
打赏
0
16 收藏
分享
加载中

引用来自“卸载防沉迷”的评论

公司也用的mongodb,想往深的学习下,这几天正在寻找一切关于mongodb的好博客。希望有机会能和博主多交流。

嗯嗯,多谢支持~!
2013/07/11 17:10
回复
举报
公司也用的mongodb,想往深的学习下,这几天正在寻找一切关于mongodb的好博客。希望有机会能和博主多交流。
2013/07/05 22:05
回复
举报
更多评论
打赏
2 评论
16 收藏
0
分享
返回顶部
顶部