第二章数据模型与查询语言 Part1
第二章 数据模型与查询语言 - part1
采用NoSQL 数据库的因素:
- 比关系数据库更好的扩展性需求(自动分片机制),包括支持超大数据集或超高写入吞吐量。(自动分片机制-支持超大数据集,LSM树数据结构(第三章)支持超高写入吞吐量)。
- 更热衷于开源软件(活跃的社区)而不是商业软件。
- 关系模型不能很好的支持一些特定的查询。
- 一些业务场景需求更加具有动态和表达力的数据模型,关系性模型的schema无法提供很好的支撑。
具体到文档数据库和文档数据库的选择上,单从模型上来考虑的话,文档数据模型胜在 模式的灵活性,由于局部性带来带来较好的性能,而对于某些应用来说,它更接近于应用程序所使用的数据结构。 关系模型,强在模型之间的联结操作、多对一、多对多关系更简洁的表达上。 另外,还需考虑事务的支持、查询的方式等。
文档模型中的one to few 、one to many、many to one 、many to many
(要为项目中的数据模型设计寻找理论支撑) 先说结论- 最佳实践:
- 🇺🇳优先使用嵌入模型
- 🪛如果嵌入的对象需要单独访问,可以不选择嵌入模型
- 🤏支持嵌入。数组不应该无限制地增长。如果在 “多 “方面有超过几百个文档,就不要嵌入它们;如果在 “多 “方面有超过几千个文档,就不要使用ObjectID引用的数组。高cardinality数组是不嵌入的一个令人信服的理由。
- 🔗不要害怕应用级的连接:如果你正确地建立索引并使用投影指定器(如第二部分所示),那么应用级的连接几乎不会比关系型数据库中的服务器端连接更昂贵。
- 💢在反范式时要考虑写/读比例。如果一个字段大部分是被读取的,而且很少被更新,那么它就是一个很好的反范式的候选者:如果你反范式一个经常被更新的字段,那么寻找和更新所有实例的额外工作很可能会压倒你从反范式中得到的收益。
- 🦅与MongoDB一样,你如何对数据进行建模完全取决于你的特定应用程序的数据访问模式。你想要结构化你的数据,以匹配你的应用程序查询和更新的方式。
one to few
db.person.findOne() { name: 'Kate Monster', ssn: '123-456-7890', addresses : [ { street: '123 Sesame St', city: 'Anytown', cc: 'USA' }, { street: '123 Avenue Q', city: 'New York', cc: 'USA' } ] }使用的方式:嵌入模型。 优点:一次查询就能获得所有数据。 缺点:无法单独获得嵌入模型数据,例如现在有一个任务跟踪系统,Person 文档中嵌入了Task 文档。现在我想获取明天所有的任务,就比较困难。
one to many
替换零件订购系统中的产品零件。每个产品可能有多达几百个替换零件。你会把零件的ObjectIDs放在产品 Document的一个数组中。 ``` db.parts.findOne() { _id : ObjectID(‘AAAA’), partno : ‘123-aff-456’, name : ‘#4 grommet’, qty: 94, cost: 0.94, price: 3.99
db.products.findOne() { name : ‘left-handed smoke shifter’, manufacturer : ‘Acme Corp’, catalog_number: 1234, parts : [ // array of references to Part documents ObjectID(‘AAAA’), // reference to the #4 grommet above ObjectID(‘F17C’), // reference to a different Part ObjectID(‘D2AA’), // etc ]
然后你在应用层面进行联结:
// Fetch the Product document identified by this catalog number
> product = db.products.findOne({catalog_number: 1234});
// Fetch all the Parts that are linked to this Product
> product_parts = db.parts.find({_id: { $in : product.parts } } ).toArray() ;
这种引用方式与嵌入方式相比,有一系列互补的优点和缺点。每个部分都是一个独立的文件,所以很容易搜索它们并独立更新它们。使用这种模式的一个交换条件是必须执行第二次查询以获得关于产品的部件的详细信息。
而且这种引用模型很容易表达多对多的关系。
### one to Squillions一到十亿
一个 "一到数十亿 "的例子可能是一个**收集不同机器的日志信息的事件日志系统**。任何给定的主机都可能产生足够多的消息来溢出16MB的文档大小,即使你存储在数组中的只是ObjectID。这就是** "父引用 "**的典型用例--你会有一个主机的文档,然后将主机的ObjectID存储在日志信息的文档中。
> db.hosts.findOne()
{
_id : ObjectID('AAAB'),
name : 'goofy.example.com',
ipaddr : '127.66.66.66'
}
>db.logmsg.findOne()
{ time : ISODate(“2014-03-28T09:42:41.382Z”), message : ‘cpu is on fire!’, host: ObjectID(‘AAAB’) // Reference to the Host document } ```
// 先找主机的文档
host = db.hosts.findOne({ipaddr : ‘127.66.66.66’}); // assumes unique index // find the most recent 5000 log message documents linked to that host last_5k_msg = db.logmsg.find({host: host._id}).sort({time : -1}).limit(5000).toArray() 总结:
- 如果cardinality是一对一的,并且不需要在父对象的上下文之外访问嵌入的对象,那么就嵌入N面。embedding
- 如果cardinality是一对多,或者如果N方对象由于任何原因应该独立,则使用对N方对象的数组引用。 child-referencing,
- 如果cardinality是一对多的话,在N-side对象中使用对One-side的引用。 parent-referencing
双向引用 two reference
“one” side -> “many” side “many” side -> “one” side 还是以
task-tracking system为例People集合(collection) 中是Person文档。tasks集合中是Task文档。 一对多的关系:People -> Task。 应用程序将需要跟踪一个人所拥有的所有任务,所以我们将需要引用人->任务。 db.person.findOne() { _id: ObjectID(“AAF1”), name: “Kate Monster”, tasks [ // array of references to Task documents ObjectID(“ADF9”), ObjectID(“AE02”), ObjectID(“AE73”) // etc ] }
另一方面,在其他一些情况下,这个应用程序将显示一个任务列表(例如,在一个多人项目中的所有任务),它需要快速找到哪个人对每个任务负责。你可以通过在Task文档中增加一个对Person的引用来优化这个问题。
db.tasks.findOne()
{
_id: ObjectID(“ADF9”),
description: “Write lesson plan”,
due_date: ISODate(“2014-04-01”),
owner: ObjectID(“AAF1”) // Reference to Person document
}
在Task文档中加入额外的 “owner”引用,意味着可以快速而容易地找到任务的所有者,但这也意味着如果你需要将任务重新分配给另一个人,你需要执行两个更新,而不是只有一个(无法保证原子性)。具体来说,你必须同时更新从个人到任务文件的引用,以及从任务到个人的引用。使用这种模式设计意味着不再可能通过一次_原子更新_将一个任务重新分配给一个新的人。
反范式设计
反范式 - many to one db.products.findOne() { name : ‘left-handed smoke shifter’, manufacturer : ‘Acme Corp’, catalog_number: 1234, parts : [ // array of references to Part documents ObjectID(‘AAAA’), // reference to the #4 grommet above ObjectID(‘F17C’), // reference to a different Part ObjectID(‘D2AA’), // etc ] } 反范式方式:查询产品时,可以直接获取零件的名称 我就直接把名称放入products表中。 db.products.findOne() { name : ‘left-handed smoke shifter’, manufacturer : ‘Acme Corp’, catalog_number: 1234, parts : [ { id : ObjectID(‘AAAA’), name : ‘#4 grommet’ }, // Part name is denormalized { id: ObjectID(‘F17C’), name : ‘fan blade assembly’ }, { id: ObjectID(‘D2AA’), name : ‘power switch’ }, // etc ] } 这要考虑具体场景下读写比例,对于 “many” side,如果是读多写少(读写比例很高)的场景,比较合适。但是,对于写/更新名称比较频繁的场景,就不太适合。 反范式 one to many 的例子和 many to one 的思想是一样的,都是“反范式”的体现。 总结: 如果双向引用能够优化你的模式,并且你愿意付出没有原子更新的代价,你可以使用双向引用。 如果你正在引用,你可以将数据从 “one “ side -> “N “ side,或者从 “N “ side转到 “one “side,进行范式。
MapReduce查询
MapReduce 是一种编程模型,用于在许多机器上批量处理海量数据。主要基于很多函数式编程语言中的map 和 reduce 函数。 MongoDB中可以使用聚合管道替代MapReduce的 执行。
引用:[https://www.mongodb.com/blog/post/6-rules-of-thumb-for-mongodb-schema-design-part-3]