使用数据的时候，一个数据项常常和另外的一个或多个数据项产生关系，比如一个“人”对象，有一个名字，可能有多个电话号码，以及多个子女，等等。
在传统的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，就像这样：
这种数据给人的感觉就像打开了一本电话簿，却发现里面只有电话号码，没有联系人姓名，真是太糟糕了阿。
引用链接
比起嵌套，引用链接更接近传统意义上的(也就是，关系型数据库术语中的）“引用”，它是两个文档之间的一种关系。
引用链接通过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/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 绑定了两个构造器，从那之后，解引用就魔术般自动完成了。
好，这样一来，使用嵌套文档和使用引用链接似乎就没有什么不同了。
嘿嘿，现在我要问你一个严肃的问题了：使用嵌套文档和链接文档，究竟有什么不同？
请你尽可能地独立思考一下，然后再继续阅读下一节。
-----
附录
自动解引用的例子：
嵌套 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 条数据都被浪费了）。
而换成以下数据，你可以只取出最新100条数据，不浪费任何资源：
(你可能发现这个查询语句还是有一些问题，嗯，的确是这样，因为它取出来的数据是倒转过来的，也即是，最新发的微薄在最低下，我们以后再来解决这个问题。）
如果你在看别人的微薄，那时候你一条信息都不需要取出来，你只需要其他个人信息，比如 name，所以，你应该使用以下语句：
实际上，使用引用连接的文档也有这个问题，而且比嵌套文档的情况更严重（因为它更慢）。
所以，无论什么情况下，请确保你使用了正确的查询语句，确保只取出所需的数据。
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
