Schema Design

#mongodbdays

Schema Design
Emily Stolfo
Ruby Engineer/Evangelist, 10gen
@EmStolfo

Tuesday, January 29, 13

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


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

Terminology


Working with Documents


Documents
Provide flexibility and
performance


Example Schema (MongoDB)


Embedding



Embedding

Linking



Relational Schema Design
Focuses on data storage


Document Schema Design
Focuses on data use


Schema Design Considerations
• What is a priority?
– High consistency
– High read performance
– High write performance

• How does the application access and manipulate data?
– Read/Write Ratio
– Types of Queries / Updates
– Data life-cycle and growth
– Analytics (Map Reduce, Aggregation)


Tools for Data Access
• Flexible Schemas
• Embedded data structures
• Secondary Indexes
• Multi-Key Indexes
• Aggregation Framework
– Pipeline operators: $project, $match, $limit,
$skip, $sort, $group, $unwind

• No Joins


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


Schema Design Example


Library Management Application
• Patrons
• Books
• Authors
• Publishers


One to One Relations
example


Modeling Patrons

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


One to One Relations
• “Contains” relationships are often embedded.
• Document provides a holistic representation of
objects with embedded entities.
• Optimized read performance.


One To Many Relations
examples


Patrons with many addresses

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", …},
]
}


One to Many Relations
example 2
Publishers and Books


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


Book Data

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

Publisher: O’Reilly Media, CA


Book Model with 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"
}
}


Book Model with Normalized Publisher
publisher = {
founded: "1980",
location: "CA"
}

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


Link with Publisher _id as a Reference
publisher = {
_id: "oreilly",
founded: "1980",
location: "CA"
}

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


Link with Book _ids as a Reference
publisher = {
founded: "1980",
location: "CA"
books: [ "123456789", ... ]
}

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


Where do you put the reference?

• Reference to single publisher on books
– Use when items have unbounded growth (unlimited # of
books)

• Array of books in publisher document
– Optimal when many means a handful of items
– Use when there is a bound on potential growth


One to Many Relations
example 3
Books and Patrons


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


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-joining data
• Document level operations are easy for the server
to handle
• Embed when the “many” objects always appear
with (viewed in the context of) their parents.
• Reference when you need more flexibility

How does your application access and manipulate data?


Many to Many Relations
example


Books and Authors
book = {
pages: 216,
language: "English"
}

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

author = {
_id: "mdirolf",
name: "Mike Dirolf",
hometown: "Albany"
}


Relation stored in Book document
book = {
authors : [
{ _id: "kchodorow", name: "Kristina Chodorow” },
{ _id: "mdirolf", name: "Mike Dirolf” }
]
pages: 216,
language: "English"
}

author = {
_id: "kchodorow",
}

author = {
_id: "mdirolf",
hometown: "Albany"
}


Relation stored in Author document

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

author = {
_id: "kchodorow",
hometown: "Cincinnati",
books: [ {book_id: 123456789, title : "MongoDB: The Definitive
Guide" }]
}


Relation stored in both documents

book = {
_id: 123456789
authors = [ kchodorow, mdirolf ]
pages: 216,
language: "English"
}

author = {
_id: "kchodorow",
hometown: "New York",
books: [ 123456789, ... ]
}

author = {
_id: "mdirolf",
hometown: "Albany",
books: [ 123456789, ... ]
}


Think about common queries
book = {
authors : [
]
pages: 216,
language: "English"
}

author = {
_id: "kchodorow",
}

db.books.find( { authors.name : "Kristina Chodorow" } )


Think about indexes
book = {
authors : [
]
pages: 216,
language: "English"
}

author = {
_id: "kchodorow",
}

db.books.createIndex( { authors.name : 1 } )


Trees
example


Parent References

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

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


Child References

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

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


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


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

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


Single Table Inheritance
example


Single Table Inheritance

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


Queues
example


Update highest priority request

db.loans.insert({
_id: 123456789,
book_id: 987654321,
pending: false,
approved: false,
priority: 3
})

//Find the highest priority request and mark as pending approval

request = db.loans.findAndModify({
query: { pending: false, book_id: 987654321 },
sort: { priority: -1},
update: { $set: { pending : true, started: new ISODate() } }
})


Summary
• Schema design is different in MongoDB
• Basic data design principals apply
• Focus on how application accesses and
manipulates data
• Evolve schema to meet changing requirements

• Application-level logic is important!


#mongodbdays

Thank You
Emily Stolfo
Ruby Engineer/Evangelist, 10gen
@EmStolfo


Schema Design

More Related Content

What's hot (6)

Viewers also liked (7)

Similar to Schema Design (20)

More from MongoDB (20)

Schema Design