Schema design mongo_boston

#MongoBoston

Schema Design
Chad Tindel
Senior Solution Architect, 10gen

Agenda
• Working with documents
• Evolving a Schema
• Queries and Indexes
• Common Patterns

Single Table En

RDBMS MongoDB
Database ➜ Database
Table ➜ Collection
Row ➜ Document
Index ➜ Index
Join ➜ Embedded Document
Foreign Key ➜ Reference

Terminology

Documents
Provide flexibility and
performance

Disk seeks and data locality

Seek = 5+ ms Read = really really fast

Post

Comment
Author Tags

Disk seeks and data locality
Article

Author

Comment
Tag

Comment
Comment
Comment
Comment
Comment

Relational Schema Design
Focus on data storage

Document Schema Design
Focus on data use

Schema Design
Considerations
• How do we manipulate the data?
– Dynamic Ad-Hoc Queries
– Atomic Updates
– Map Reduce

• What are the access patterns of the application?
– Read/Write Ratio
– Types of Queries / Updates
– Data life-cycle and growth rate

Data Manipulation
• Conditional Query Operators
– Scalar: $ne, $mod, $exists, $type, $lt, $lte, $gt, $gte, $ne
– Vector: $in, $nin, $all, $size

• Atomic Update Operators
– Scalar: $inc, $set, $unset
– Vector: $push, $pop, $pull, $pushAll, $pullAll, $addToSet

Data Access
• Flexible Schemas
• Ability to embed complex data structures
• Secondary Indexes
• Compound Indexes
• Multi-Value Indexes (Indexes on Arrays)
• Aggregation Framework
– $project, $match, $limit, $skip, $sort, $group, $unwind

• No Joins

Library Management
Application
• Patrons
• Books
• Authors
• Publishers

An Example
One to One Relations

Modeling Patrons

patron = { patron = {
_id: "joe" _id: "joe"
name: "Joe Bookreader” name: "Joe Bookreader",
} address: {
street: "123 Fake St. ",
address = { city: "Faketon",
patron_id = "joe",
state: "MA",
street: "123 Fake St. ",
city: "Faketon", zip: 12345
state: "MA", }
zip: 12345 }
}

One to One Relations
• Mostly the same as the relational approach
• Generally good idea to embed “contains”
relationships
• Document model provides a holistic
representation of objects

An Example
One To Many Relations

Modeling Patrons

patron = {
_id: "joe"
name: "Joe Bookreader",
join_date: ISODate("2011-10-15"),
addresses: [
{street: "1 Vernon St.", city: "Newton", state: "MA", …},
{street: "52 Main St.", city: "Boston", state: "MA", …},
]
}

Publishers and Books
• Publishers put out many books
• Books have one publisher

Book

MongoDB: The Definitive Guide,
By Kristina Chodorow and Mike Dirolf
Published: 9/24/2010
Pages: 216
Language: English

Publisher: O’Reilly Media, CA

Modeling Books – Embedded
Publisher

book = {
title: "MongoDB: The Definitive Guide",
authors: [ "Kristina Chodorow", "Mike Dirolf" ]
published_date: ISODate("2010-09-24"),
pages: 216,
language: "English",
publisher: {
name: "O’Reilly Media",
founded: "1980",
location: "CA"
}
}

Modeling Books & Publisher
Relationship
publisher = {
founded: "1980",
location: "CA"
}

book = {
pages: 216,
language: "English"
}

Publisher _id as a Foreign
Key
publisher = {
_id: "oreilly",
founded: "1980",
location: "CA"
}

book = {
pages: 216,
publisher_id: "oreilly"
}

Book _id as a Foreign Key
publisher = {
founded: "1980",
location: "CA"
books: [ "123456789", ... ]
}

book = {
_id: "123456789",
pages: 216,
language: "English"
}

Where do you put the foreign
Key?
• Array of books inside of publisher
– Makes sense when many means a handful of items
– Useful when items have bound on potential growth

• Reference to single publisher on books
– Useful when items have unbounded growth (unlimited # of
books)
• SQL doesn’t give you a choice, no arrays

Another Example
One to Many Relations

Books and Patrons
• Book can be checked out by one Patron at a
time
• Patrons can check out many books (but not
1000s)

Modeling Checkouts
patron = {
_id: "joe"
address: { ... }
}

book = {
_id: "123456789"
authors: [ "Kristina Chodorow", "Mike Dirolf" ],
...
}

Modeling Checkouts
patron = {
_id: "joe"
address: { ... },
checked_out: [
{ _id: "123456789", checked_out: "2012-10-15" },
{ _id: "987654321", checked_out: "2012-09-12" },
...
]
}

De-normalization
Provides data locality

De-normalize for speed

Modeling Checkouts -- de-
normalized
patron = {
_id: "joe"
address: { ... },
checked_out: [
{ _id: "123456789",
checked_out: ISODate("2012-10-15")
},
{ _id: "987654321"
title: "MongoDB: The Scaling Adventure", ...
}, ...
]
}

Referencing vs. Embedding
• Embedding is a bit like pre-joined data
• Document level ops are easy for server to
handle
• Embed when the “many” objects always appear
with (viewed in the context of) their parents.
• Reference when you need more flexibility

An Example
Single Table Inheritance

Single Table Inheritance

book = {
kind: ”loanable"
locations: [ ... ]
pages: 216,
publisher: {
founded: "1980",
location: "CA"
}
}

An Example
Many to Many Relations

Books and Authors
book = {
authors = [
{ _id: "kchodorow", name: ”Kristina Chodorow” },
{ _id: "mdirolf", name: ”Mike Dirolf” }
]
pages: 216,
language: "English"
}

author = {
_id: "kchodorow",
name: "Kristina Chodorow",
hometown: "New York"
}

db.authors.find ( { _id : ‘kchodorow’ } )
db.books.find( { authors.id : ‘kchodorow’ } )

Modeling Trees
• Parent Links
- Each node is stored as a document
- Contains the id of the parent
• Child Links
- Each node contains the id’s of the children
- Can support graphs (multiple parents / child)

Parent Links

book = {
pages: 216,
category: "MongoDB"
}

category = { _id: MongoDB, parent: Databases }
category = { _id: Databases, parent: Programming }
category = { _id: Programming }

Child Links

book = {
_id: 123456789,
pages: 216,
language: "English"
}

category = { _id: MongoDB, children: [ 123456789, … ] }
category = { _id: Databases, children: [ MongoDB, Postgres }
category = { _id: Programming, children: [ DB, Languages ] }

Array of Ancestors
book = {
pages: 216,
parent: ”MongoDB”,
categories: [ Programming, Databases, MongoDB ]
}

book = {
title: "MySQL: The Definitive Guide",
authors: [ ”Michael Kofler" ],
pages: 320,
parent: ”MySQL",
categories: [ Programming, Databases, MySQL ]
}

db.books.find( { categories : MongoDB } )

Book Document

book = {
_id: 123456789,
pages: 216,
available: 3
}

db.books.findAndModify({
query: { _id: 123456789, available: { "$gt": 0 } },
update: { $inc: { available: -1 } }
})

#ConferenceHashTag

Thank You
Speaker Name
Job Title, 10gen

Schema design mongo_boston

More Related Content

What's hot (20)

Similar to Schema design mongo_boston (19)

More from MongoDB (20)

Schema design mongo_boston

Editor's Notes