Agile Schema Design: An introduction to MongoDB

#CampJS

Agile Schema Design:
An introduction to MongoDB
Stephen Steneker @stennie
Technical Services Engineer, 10gen Australia

MongoDB is a ___________ database
•  Document
•  Open source
•  High performance
•  Horizontally scalable
•  Full featured

Document Database
•  Not for .PDF & .DOC ﬁles
•  A document is essentially an associative array
•  Document == JSON object
•  Document == PHP Array
•  Document == Python Dict
•  Document == Ruby Hash
•  etc

Open Source
•  MongoDB is an open source project
•  On GitHub (mongodb/mongo)
•  Licensed under the AGPL
•  Started & sponsored by 10gen
•  Commercial licenses available
•  Contributions welcome

High Performance
•  Written in C++
•  Extensive use of memory-mapped ﬁles

i.e. read-through write-through memory caching.
•  Runs nearly everywhere
•  Data serialized as BSON (fast parsing)
•  Full support for primary & secondary indexes
•  Document model = less work

www.etiennemansard.com

Horizontally Scalable

Full Featured
•  Ad Hoc queries
•  Real time aggregation
•  Rich query capabilities
•  Traditionally consistent
•  Geospatial features
•  Support for most programming languages
•  Flexible schema

Scalability & Performance

Memcached
MongoDB

RDBMS

Depth of Functionality

Database Landscape

Thousands
of
organisa.ons
are

using
MongoDB.

Common Use Cases
•  Content Management –MTV Networks, Forbes, Shutterﬂy
•  High Volume Data Feeds – ShareThis, Stripe, Wordnik
•  Operational Intelligence – Intuit, Buddy Media, Traackr
•  Product Data Management– CustomInk, Totsy
•  Social Networking – foursquare, Disney
More case studies and presentations:
http://www.10gen.com/use-cases

RDBMS
Table, View
Row
Index
Join
Foreign Key
Partition

Terminology

➜
➜
➜
➜
➜
➜

MongoDB
Collection
Document
Index
Embedded Document
Reference
Shard

Category
·Name
·URL

User
·Name
·Email address

Article
·Name
·Slug
·Publish date
·Text

Tag
·Name
·URL

Comment
·Comment
·Date
·Author

Typical (relational) ERD

Article

User
·Name
·Email address

·Name
·Slug
·Publish date
·Text
·Author

Comment[]
·Comment
·Date
·Author

Tag[]
·Value

Category[]
·Value

MongoDB ERD

We will build a library
management application
http://www.ﬂickr.com/photos/somegeekintn/3484353131/

First step in any application is

Determine your entities

Library Management Application
Entities
•  Library Patrons (users)
•  Books (catalog)
•  Authors
•  Publishers
•  Categories ??

In a relational based app

We would start by doing
schema design

Relational schema design
•  Large ERD Diagrams
•  Complex create table statements
•  ORMs to map tables to objects
•  Tables just to join tables together
•  For this simple app we'd have 5 tables and 5 join

tables
•  Lots of revisions until we get it just right

In a MongoDB based app

We start building our app
and let the schema evolve

MongoDB collections
•  Users
•  Books
•  Authors
•  Publishers

Start with an object
(or array, hash, dict, etc)
user = {
username:

'stennie',

first_name: 'Stephen',
last_name:
}

'Steneker'

Insert the record
> use library
switched to db library
> db.users.insert(user)

No database or collection creation needed

Querying for the user
> db.users.findOne()
{
"_id" : ObjectId("50804d0bd94ccab2da652599"),
"username" : "stennie",
"first_name" : "Stephen",
"last_name" : "Steneker"
}

_id
•  _id is the primary key in MongoDB
•  Automatically indexed
•  Automatically created as an ObjectId if not

provided

•  Any unique immutable value could be used

ObjectId
•  ObjectId is a special 12 byte value
•  Guaranteed to be unique across your cluster
•  ObjectId("50804d0bd94ccab2da652599")

|-------------||---------||-----||---------|
ts
mac pid inc

Creating an Author
> db.author.insert({
first_name: 'j.r.r.',
last_name:

'tolkien',

bio: 'J.R.R. Tolkien (1892.1973), beloved
throughout the world as the creator of The Hobbit and
The Lord of the Rings, was a professor of Anglo-Saxon
at Oxford, a fellow of Pembroke College, and a fellow
of Merton College until his retirement in 1959. His
chief interest was the linguistic aspects of the early
English written tradition, but even as he studied these
classics he was creating a set of his own.'
})

Querying for our Author
> db.author.findOne( { last_name : 'tolkien' } )
{
"_id" : ObjectId("507ffbb1d94ccab2da652597"),
"first_name" : "j.r.r.",
"last_name" : "tolkien",
"bio" : "J.R.R. Tolkien (1892.1973), beloved
classics he was creating a set of his own."
}

Creating a Book
> db.books.insert({
title: 'fellowship of the ring, the',
author: ObjectId("507ffbb1d94ccab2da652597"),
language: 'english',
genre: ['fantasy', 'adventure'],
publication: {
name: 'george allen & unwin',
location: 'London',
date: new Date('21 July 1954'),
}
})
http://society6.com/PastaSoup/The-Fellowship-of-the-Ring-ZZc_Print/

Multiple values per key
> db.books.findOne({language: 'english'}, {genre: 1})
{
"_id" : ObjectId("50804391d94ccab2da652598"),
"genre" : [
"fantasy",
"adventure"
]
}

Querying for key with
multiple values
> db.books.findOne({genre: 'fantasy'}, {title: 1})
{
"title" : "fellowship of the ring, the"
}

Query key with single value or
multiple values the same way.

Nested values
> db.books.findOne({}, {publication: 1})
{
"_id" : ObjectId("50804ec7d94ccab2da65259a"),
"publication" : {
"name" : "george allen & unwin",
"location" : "London",
"date" : ISODate("1954-07-21T04:00:00Z")
}
}

Reach into nested values
using dot notation
> db.books.findOne(
{'publication.date' :
{ $lt : new Date('21 June 1960')}
}
)
{
"title" : "fellowship of the ring, the",
"author" : ObjectId("507ffbb1d94ccab2da652597"),
"language" : "english",
"genre" : [ "fantasy”, "adventure" ],
"publication" : {
"date" : ISODate("1954-07-21T04:00:00Z")
}
}

Update books
> db.books.update(
{"_id" : ObjectId("50804391d94ccab2da652598")},
{ $set : {
isbn: '0547928211',
pages: 432
}
})

Change how you work with
the data and the database follows

The updated Book document
db.books.findOne()
{
"genre" : [ "fantasy", "adventure" ],
"isbn" : "0395082544",
"pages" : 432,
"publication" : {
"date" : ISODate("1954-07-21T04:00:00Z")
},
}

Creating indexes
> db.books.ensureIndex({title: 1})
> db.books.ensureIndex({genre : 1})
>
db.books.ensureIndex({'publication.date':
-1})

1: ascending sort
-1: descending sort

Querying with regular expressions
> db.books.findOne({title : /^fell/})
{
"isbn" : "0395082544",
"pages" : 432,
"publication" : {
"date" : ISODate("1954-07-21T04:00:00Z")
},
}

Adding a few more books
> db.books.insert({
title: 'two towers, the',
isbn : "034523510X",
pages: 447,
publication: {
location: 'London',
date: new Date('11 Nov 1954'),
}
})
http://society6.com/PastaSoup/The-Two-Towers-XTr_Print/

Adding a few more books
> db.books.insert({
title: 'return of the king, the',
isbn : "0345248295",
pages: 544,
publication: {
location: 'London',
date: new Date('20 Oct 1955'),
}
})
http://society6.com/PastaSoup/The-Return-of-the-King-Jsc_Print/

Cursors
> db.books.find(
{ author: ObjectId("507ffbb1d94ccab2da652597")})
.sort({ 'publication.date' : -1})
.limit(1)
{
"_id" : ObjectId("5080d33ed94ccab2da65259d"),
"title" : "return of the king, the",
"isbn" : "0345248295",
"pages" : 544,
"publication" : {
"date" : ISODate("1955-10-20T04:00:00Z")
}
}

Paging
page_num = 3;
results_per_page = 10;
cursor = db.books.find()
.sort({ "publication.date" : -1 })
.skip((page_num - 1) * results_per_page)
.limit(results_per_page);

Finding author by book
Ø  book = db.books.findOne({"title" : "return of the

king, the”})
> db.author.findOne({_id: book.author})
{
"_id" : ObjectId("507ffbb1d94ccab2da652597"),
"first_name" : "j.r.r.",
"last_name" : "tolkien",
"bio" : "J.R.R. Tolkien (1892.1973), beloved
classics he was creating a set of his own."
}

Real applications are not
built in the shell

MongoDB has native
bindings for over 12
languages

Agile Schema Design: An introduction to MongoDB

MongoDB drivers
•  Ofﬁcial Support for 12 languages
•  Community drivers for tons more
•  Drivers connect to mongo servers
•  Drivers translate BSON into native types
•  mongo shell is not a driver, but works like one in

some ways
•  Installed using typical means (npm, pecl, gem, pip)

Install from Homebrew, Mac Ports,
tarball, or m!

http://education.10gen.com

http://mongodbsydney2013.eventbrite.com/

#CampJS

Questions?
Stephen Steneker @stennie
Technical Services Engineer, 10gen Australia

Agile Schema Design: An introduction to MongoDB

More Related Content

What's hot (19)

Similar to Agile Schema Design: An introduction to MongoDB (20)

Recently uploaded (20)

Agile Schema Design: An introduction to MongoDB