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

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

 

在传统的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': [12, 26, 30]]  

 

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

 

 

引用链接

 

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

 

引用链接通过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

时间: 2024-12-25 21:49:45

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

【MOS】如何利用RMAN可传输表空间迁移数据库到不同字节序的平台(文档 ID 1983639.1)

如何利用 RMAN 可传输表空间迁移数据库到不同字节序的平台 (文档 ID 1983639.1) 适用于: Oracle Database - Enterprise Edition - 版本 10.1.0.2 到 12.1.0.1 [发行版 10.1 到 12.1]本文档所含信息适用于所有平台******************* 警告 ************* Document 1334152.1 Corrupt IOT when using Transportable Tablespace

php将数据库中所有内容生成静态html文档的代码_php技巧

复制代码 代码如下: <?php /* author:www.5dkx.com done:生成html文档 date:2009-10-27 */ require_once("conn.php"); if($_GET['all']) { /*获取数据库记录,以便于生成html文件有个文件名*/ $sqlquery = "select * from $tbname"; $result = mysql_query($sqlquery,$conn)or die(&qu

请问怎么从MSSQL2000数据库读取image字段存的word文档显示在JSP页面上

问题描述 我的数据库是SQLServer2000的,数据字段类型是image,里面保存了word,已经把word存到image字段里面了.就是不知道怎么读取然后显示在JSP页面上,请兄弟们帮忙解决.谢谢<%@ page language="java" contentType="application/msword;charset=UTF-8" %><%@ page import="java.io.*,java.sql.*"%&g

基于C#的MongoDB数据库开发应用(2)--MongoDB数据库的C#开发

在上篇博客<基于C#的MongoDB数据库开发应用(1)--MongoDB数据库的基础知识和使用>里面,我总结了MongoDB数据库的一些基础信息,并在最后面部分简单介绍了数据库C#驱动的开发 ,本文继续这个主题,重点介绍MongoDB数据库C#方面的使用和封装处理过程,利用泛型和基类对象针对数据访问层进行的封装处理. 前面介绍到,当前2.2版本的数据库C#驱动的API,支持两种不同的开发接口,一个是基于MongoDatabase的对象接口,一个是IMongoDatabase的对象接口,前者中

MongoDB数据库顺序读性能评估测试

    最近,公司一项目实施需要对MongoDB数据库的顺序读性能进行评估测试,已备项目实施提供决策依据.     问题:主单对应的明细表关系,每一条主单在明细表中都有大量的明细存在,而明细单独以单个文档存储在mongodb中会因为key-value关系浪费大量的key值空间.     解放方法:将明细表中的同一主单对应的明细压缩到一个文档中,提取冗余字段属性,将明细特有key-value组织成一个数组,这样数据相对集中,可以提高mongodb的顺序读性能.     前提:主单对应的明细条数不能

linux中MongoDB数据库详细配置说明

启动MongoDB有2种方式,一是直接指定配置参数,二是指定配置文件.这里先介绍配置文件,启动方式如下: mongod --config /etc/mongodb.conf 配置如下: verbose:日志信息冗余.默认false.提高内部报告标准输出或记录到logpath配置的日志文件中.要启用verbose或启用verbosity 用vvvv参数,如: verbose = true vvvv = true ps:启动verbose冗长信息,它的级别有 vv~vvvvv,v越多级别越高,在日志

mongoDB 文档查询

在关系型数据库中,可以实现基于表上各种各样的查询,以及通过投影来返回指定的列.对于NoSQL mongoDB而言,所有能够在单表上完成的查询,在mongoDB中也可以完全胜任.除此之外,由于mongoDB支持基于文档嵌套以及数组,因此mongoDB也可以实现基于嵌套文档和数组的查询.具体见下文描述. 预备热身 Linux下快速安装MongoDB Windows平台下安装MongoDB mongoDB 启动与停止 mongo shell连接到mongoDB及shell提示符下执行js脚本 mong

mongoDB 文档更新

mongoDB对于文档的更新,既可以实现文档的更新,也可以实现文档随意的增减键(列),这是与传统的关系型数据库最大的不同之处,也就是所谓的无模式带来的一定程度上的便利.即mongoDB支持文档更新,也支持文档替换.本文给出了mongoDB更新语法及示例. 预备热身 Linux下快速安装MongoDB Windows平台下安装MongoDB mongoDB 启动与停止 mongo shell连接到mongoDB及shell提示符下执行js脚本 mongoDB简介及关键特性 SQL与mongoDB对

MongoDB中对文档的增删查改基本操作方法总结_MongoDB

插入文档:insert() 方法 要插入数据到 MongoDB 集合,需要使用 MongoDB 的  insert() 或 save() 方法. 语法: insert() 命令的基本语法如下: >db.COLLECTION_NAME.insert(document) 例子:  >db.mycol.insert({    _id: ObjectId(7df78ad8902c),    title: 'MongoDB Overview',     description: 'MongoDB is