This document discusses building a location-based check-in app using MongoDB. It begins with an introduction to MongoDB's key features like being document-oriented, open source, high performance, and horizontally scalable. It then demonstrates modeling the app's entities of users, places, and check-ins as MongoDB collections. It shows examples of queries, indexes, and updates used in the app. The document concludes by discussing more advanced features like aggregation and deployment options for MongoDB.

1. Building your First App with
MongoDB
Blossom Coryat
Solutions Architect, 10gen

2. Today‟s Talk
• Introduction to MongoDB
• Discuss data modeling, queries, indexes,
updates and aggregation in MongoDB within
the context of building a location-based app

3. What is MongoDB?

4. MongoDB is a ___________
database
• Document Oriented
• Open source
• High performance
• Highly Available
• Horizontally scalable
• Full featured

5. Document Oriented
• A document is essentially an associative array
• Document == JSON object
• Document == PHP Array
• Document == Python Dict
• Document == Ruby Hash
• Etc.

6. Open Source
• MongoDB is an open source project
– Started and maintained by 10gen
• Licensed under the AGPL
• Commercial licenses available
• On GitHub
• Contributions welcome

7. High Performance
• Written in C++
• Runs nearly everywhere
• Extensive use of memory-mapped files
• Data serialized as BSON (fast parsing)
• Full support for primary & secondary indexes
• Document model = less work

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

9. MongoDB drivers
• Official Support for 12 languages
• Community drivers for tons more
• Drivers connect to mongo servers
• Drivers translate BSON into native types
• Installed using typical means (npm, pecl, gem,
pip)

12. Highly Available

13. Replica Sets
• Redundancy and
Failover
• Multi-DC deployments
• Zero downtime for
upgrades and
maintenance

14. Horizontally Scalable

15. Sharding
• Partition your
data
• Auto-balancing
• Scale write
throughput
• Increase
capacity

16. Document Database

17. RDBMS MongoDB
Row ➜ Document
Table, View ➜ Collection
Index ➜ Index
Join ➜ Embedded Document
Foreign ➜ Reference
Key
Partition ➜ Shard
Terminology

18. Typical (relational) ERD

19. MongoDB ERD

20. Example Document
{
_id : ObjectId("4c4ba5c0672c685e5e8aabf3"),
author : "Blossom",
date : ISODate("2012-11-02T11:52:27.442Z"),
title: "Intro to MongoDB",
tags : [ "tech", "databases”, ”documents" ],
comments : [{
author : "Fred",
date : ISODate("2012-11-03T17:22:21.124Z"),
text : ”interesting article, lots of great nuggets of
wisdom"
}],
comment_count : 1
}

21. Building a check-in web
app

22. Requirements
• Users should be able to check in to a location
• Should be able to view check-ins by location
• Ability to assign categories to places
• Find nearby places
• Generate check-in statistics

23. First step in any application is
Determine your entities

24. Check-in App Entities
• People checking in
• Places to check in to
• Check-in events

25. In a relational based app
We would start by doing
schema design

26. Relational schema design
• Large entity relationship diagrams
• Complex create table statements
• Tables just to join tables together
• ORMs to map tables to objects
• Lots of revisions until we get it just right

27. In a MongoDB based app
We start building our
and let the schema evolve
app

28. MongoDB collections
• Users
• Places
• Check-ins
– Separate collection to manage discrete check-in events
and support high workload of writes

29. We‟ll use the JS shell to get
started

30. Start with an object
(or array, hash, dict, etc)
> user = {
firstname: 'fred',
lastname: 'jones',
}

31. Insert the record
> db.users.insert(user)
No collection creation
needed

32. Querying for the user
> db.users.findOne()
{
"_id" : ObjectId("50804d0bd94ccab2da652599"),
"firstname" : "fred",
"lastname" : "jones"
}

33. _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

34. ObjectId
• ObjectId is a special 12 byte value
• Guaranteed to be unique across your cluster
• ObjectId("50804d0bd94ccab2da652599")
|---------||-----||-----||--------|
ts mac pid inc

35. Places v1
> db.places.insert({
name: “Exploratorium”,
address: “3601 Lyon St”
city: “San Francisco”,
postcode: 94123
}

36. Places v1
> db.places.insert({
name: “Exploratorium”,
address: “3601 Lyon St”
city: “San Francisco”,
postcode: 94123
}
> db.places.find({name:”Exploratorium”})

37. Places v2
> db.places.insert({
name: “Exploratorium”,
address: “3601 Lyon St”
city: “San Francisco”,
postcode: 94123,
categories: [“Social”, “Arts”, “Museums”]
}

38. Places v2
> db.places.insert({
name: “Exploratorium”,
address: “3601 Lyon St”
city: “San Francisco”,
postcode: 94123,
categories: [“Social”, “Arts”, “Museums”]
}
> db.places.ensureIndex({categories: 1})
> db.places.find({categories: ”Social”})

39. Places v3
> db.places.insert({
name: “Exploratorium”,
address: “3601 Lyon St”
city: “San Francisco”,
postcode: 94123,
categories: [“Social”, “Arts”, “Museums”],
location: [37.803963,-122.448531]
}
> db.places.ensureIndex({location: “2d”})
> db.places.find({location:{$near:[37.81,-122.45]}})

40. Indexes
• Can be created on any field
– Including fields within sub-documents or embedded arrays
• Support for compound indexes on any
combination of keys
• Indexes should exist for primary, common, and
user-facing queries

41. Indexes on Places
// creating indexes
> db.places.ensureIndex({name:1})
> db.places.ensureIndex({categories:1})
> db.places.ensureIndex({location:”2d”})
// finding by regular expression
> db.places.find({name:/^explor/i})
// finding nearby
> db.places.find({location:{$near:[37.81,-122.45]}})
// finding by category
> db.places.find({categories: ”Social”})

42. Updating Documents
• MongoDB supports atomic, in-place document updates
• $inc
• $set, $unset
• $push, $pushAll
• $addToSet, $each
• $pop, $pull, $pullAll
• $rename
• $bit

43. Updating
> db.checkins.insert({
place_id: pid,
user_id: uid,
datetime: new Date()
})
// update the “checkins” count on place and user
// “checkins” will be added if it doesn‟t exist
> db.places.update({_id: pid}, {$inc: {checkins: 1}})
> db.users.update({_id: uid}, {$inc: {checkins: 1}})

44. Simple Statistics
// find the last 10 checkins for a place:
> p = db.places.find({name:”Exploratorium”})
> db.checkins.find({place_id:p[„_id‟]})
.sort({datetime:-1}).limit(10)
// how many people checked in today
> db.checkins.find({place_id:p[„_id‟],
datetime: {$gt: midnight}}).count()

45. Aggregation Framework
• Documents pass through a pipeline of
operations
• Mechanism to calculate aggregate values across
your data
• Similar functionality to GROUP BY and related
SQL operators
• Along with computation, data can be reshaped
– Add computed fields
– Create virtual sub-objects
– Extract sub-fields

46. Aggregation Framework
Operators
• $project
• $match
• $limit
• $skip
• $unwind
• $group
• $sort

48. Advanced Statistics
// checkins per place per day of the week
> db.checkins.aggregate(
{$project: {
place_id:1,
dotw: { $dayOfWeek: ”$datetime”}
}},
{$group: {
_id: {place_id: “$place_id”, dotw: “$dotw”},
count: {$sum: 1}
}})

49. Deployment

50. Deployment
• Single server
- need a strong backup plan
P

51. Deployment
• Single server
- need a strong backup plan
P
• Replica sets P S S
- High availability
- Automatic failover

52. Deployment
• Single server
- need a strong backup plan
P
• Replica sets P S S
- High availability
- Automatic failover
P S S
• Sharded
- Horizontally scale
- Auto balancing P S S

53. Learn More:
10gen.com/presentations
education.10gen.com