Reference Cards

for MongoDB
What is MongoDB?
MongoDB is an open-source, general
purpose database.

Instead of storing data in rows and columns as a relational

database does, MongoDB uses a document data model,
and stores a binary form of JSON documents called BSON.
Documents contain one or more fields, and each field contains
a value of a specific data type, including arrays and binary data.
Documents are stored in collections, and collections are stored
in databases. It may be helpful to think of documents as roughly
equivalent to rows in a relational database; fields as equivalent
to columns; and collections as tables. There are no fixed
schemas in MongoDB, so documents can vary in structure and
can be adapted dynamically.

MongoDB provides full index support, including secondary,

compound, and geospatial indexes. MongoDB also features a
rich query language, atomic update modifiers, text search, the
Aggregation Framework for analytics similar to SQL GROUP
BY operations, and MapReduce for complex in-place data
analysis.

Built-in replication with automated failover provides high

availability. Auto-sharding enables horizontal scaling for large
deployments. MongoDB also provides native, idiomatic drivers
for all popular programming languages and frameworks to
make development natural.
Queries
Queries
Queries and What They Match

Docs where a is 10, or an array containing

{a: 10}
the value 10.

{a: 10, b: “hello”} Docs where a is 10 and b is “hello”.

Docs where a is greater than 10. Also

{a: {$gt: 10}} available: $lt (<), $gte (>=), $lte
(<=), and $ne (!=).

{a: {$in: [10, “hello”]}} Docs where a is either 10 or “hello”.

Docs where a is an array containing both

{a: {$all: [10, “hello”]}}
10 and “hello”.

Docs where a is an embedded document

{"a.b": 10}
with b equal to 10.

Docs where a is an array that contains an

{a: {$elemMatch: {b: 1, c: 2}}} element with both b equal to 1 and c equal
to 2.

{$or: [{a: 1}, {b: 2}]} Docs where a is 1 or b is 2.

Docs where a begins with the letter m.

{a: /^m/} One can also use the regex operator: {a:
{$regex: “^m”}}.

{a: {$mod: [10, 1]}} Docs where a mod 10 is 1.

Docs where a is a string. See bsonspec.org

{a: {$type: 2}}
for more.

Docs that contain ”hello” on a text

{ $text: { $search: “hello” } }
search. Requires a text index.
Queries and What They Match (continued)

{a: {$near:
{$geometry:{
Docs sorted in order of nearest to farthest
type: “Point”,
from the given coordinates. For geospatial
coordinates: [ -73.98,
queries one can also use $geoWithin
40.75 ]
}} and $geoIntersects operators.
} }

Not Indexable Queries

The following queries cannot use indexes. These query forms should normally be
accompanied by at least one other query term which does use an index.

Docs where a is anything but 10 or

{a: {$nin: [10, “hello”]}}
“hello”.

Docs where a is an array with exactly 3

{a: {$size: 3}}
elements.

{a: {$exists: true}} Docs containing an a field.

Docs where a matches the regular

{a: /foo.*bar/}
expression foo.*bar.

Docs where a is not a string. $not

{a: {$not: {$type: 2}}}
negates any of the other query operators.

For More Information

http://docs.mongodb.org/manual/tutorial/query-documents/
http://docs.mongodb.org/manual/reference/operator/query/

Queries
Updates
Updates
Field Update Modifiers

{$inc: {a: 2}} Increments a by 2.

{$set: {a: 5}} Sets a to the value 5.

{$unset: {a: 1}} Removes the a field from the document.

Sets a to the greater value, either current

{$max: { a: 10 } }
or 10. If a does not exist sets a to 10.

Sets a to the lower value, either current or

{$min: {a: -10}}
-10. If a does not exist sets a to -10.

Sets a to the product of the current value

{$mul: { a: 2 } }
of a and 2. If a does not exist sets a to 0.

{$rename: { a: “b”} } Renames field a to b.

{ $setOnInsert: { a: 1 } },
Sets field a to 1 in case of upsert
{ upsert: true }
operation.

Sets field a with the current date.

{$currentDate: { a: { $type:
$currentDate can be specified as date
“date”} } }
or timestamp. Note that as of 3.0, date and
timestamp are not equivalent for sort order.
Performs the bitwise and operation over a
field. If a is 12:
1100
{ $bit: { a: { and: 7 } } } 0111
-------
0100
Supports and|xor|or bitwise operators.
Array Update Operators

{$push: {a: 1}} Appends the value 1 to the array a.

{$push: {a: {$each: [1, 2]}}} Appends both 1 and 2 to the array a.

Appends the value 1 to the array a (if the

{$addToSet: {a: 1}}
value doesn’t already exist).

{$addToSet: {a: {$each: [1, Appends both 1 and 2 to the array a (if
2]}}} they don’t already exist).

{$pop: {a: 1}} Removes the last element from the array a.

{$pop: {a: -1}} Removes the first element from the array a.

Removes all occurrences of 5 from the

{$pull: {a: 5}}
array a.

Removes multiple occurrences of 5 or 6

{$pullAll: {a: [5, 6]}}
from the array a.

For More Information

http://docs.mongodb.org/manual/reference/operator/update/

Updates
Aggregation
Framework
Aggregation Framework
The aggregation pipeline is a framework for data aggregation modeled on the
concept of data processing pipelines. Documents enter a multi-stage pipeline that
transforms the documents into aggregated results. Pipeline stages appear in an array.
Documents pass through the stages in sequence. Structure an aggregation pipeline
using the following syntax:
db.collection.aggregate( [ { <stage> }, ... ] )

Aggregation Framework Stages

Passes only documents

{$match: { a: 10 }} Similar to find()
where a is 10.

Reshapes each document

{$project: { a: 1, Similar to find()
to include only field a,
_id:0}} projection
removing others.
Reshapes each document
{$project: { new_a: to include only _id and the {a:1} =>
"$a" }} new field new_a with the {new_a:1}
value of a.
Reshapes each document to
{$project: { a: {$ad- {a:1, b:10} =>
include only _id and field
d:[“$a”, “$b”]}}} {a: 11}
a, set to the sum of a and b.
{$project: { stats: Reshapes each document
{ to contain only _id and
{a: 10, b:2} =>
value: “$a”, the new field stats which
{ stats:{ value:
fraction: {$di- contains embedded fields
10, fraction:
vide: [“$a”, “$b”]} value, set to the value of a,
} 5} }
and fraction, set to the
} } value of a divided by b.
{a:”hello”},
{a:”goodbye”},
{$group: {
Groups documents by field {a:”hello”} =>
_id: “$a”,
a and computes the count {_id:”hello”,
count:{$sum:1}
of each distinct a value. count:2}, {_
} }
id:”goodbye”,
count:1}
Aggregation Framework Stages (continued)

{a:1, b:”John”},
Groups documents by field
{$group: { _id: “$a”, {a:1, b:”Mary”}
a with new field names
names: {$addToSet: => {_id:1,
consisting of a set of b
“$b”}} } names:[“John”,
values.
“Mary”] }
Deconstructs array field a {a: [2,3,4]} =>
{$unwind: “$a”} into individual documents of {a:2}, {a:3},
each element. {a:4}
Limits the set of documents
{$limit: 10} to 10, passing the first 10
documents.

Sorts results by field a

{$sort: {a:1}}
ascending.

Skips the first 10

{$skip: 10} documents and passes the
rest.
Writes resulting documents
Must be the last stage
{$out: “myResults”} of the pipeline into the
of the pipeline.
collection “myResults”.

For More Information

http://docs.mongodb.org/master/core/aggregation-introduction/

Aggregation Framework
Indexing
Indexing

Index Creation Syntax

db.coll.createIndex(<key_pattern>, <options>)
Creates an index on collection coll with given key pattern and options.

Indexing Key Patterns

{a:1} Simple index on field a.

{a:1, b:-1} Compound index with a ascending and b descending.

{“a.b”: 1} Ascending index on embedded field “a.b”.

Text index on field a. A collection can have at most one

{a: “text”}
text index.

Geospatial index where the a field stores GeoJSON

{a: “2dsphere”}
data. See documentation for valid GeoJSON formatting.

Hashed index on field a. Generally used with hash-

{a: “hashed”}
based sharding.
Index options

Creates an index that requires all values of the

{unique: true}
indexed field to be unique.

Creates this index in the background; useful when

{background: true} you need to minimize index creation performance
impact.
Specifies a custom name for this index. If not
{name: “foo”} specified, the name will be derived from the key
pattern.

Creates entries in the index only for documents

{sparse: true}
having the index key.

Creates a time to live (TTL) index on the index key.

This will force the system to drop the document after
{expireAfterSeconds:360}
3600 seconds expire. Only works on keys of date
type.

{default_language: Used with text indexes to define the default language

‘portuguese’} used for stop words and stemming.

Examples

db.products.createIndex( Creates ascending index on supplier

{‘supplier’:1}, {unique:true}) assuring unique values.

db.products.createIndex(
{‘description’: ‘text’}, Creates text index on description key
{‘default_language’: using Spanish for stemming.
‘spanish’})
Creates ascending sparse index on
db.products.createIndex( { regions key. If regions is an array –
‘regions’: 1 }, {sparse:true}) e.g., regions: [‘EMEA’, ‘NA’,
‘LATAM’] – will create a multikey index.
db.stores.createIndex(
Creates a 2dsphere geospatial index on
{location: “2dsphere”})
location key.

Indexing
Administration

Gets a list of all indexes on the products

db.products.getIndexes()
collection.

db.products.reIndex() Rebuilds all indexes on this collection.

Drops the index with key pattern {x:

1, y: -1}. Use db.products.
db.products.dropIndex({x: 1, y: dropIndex(‘index_a’) to drop index
-1}) named index_a. Use db.products.
dropIndexes() to drop all indexes on
the products collection.

For More Information

http://docs.mongodb.org/master/core/indexes-introduction/

Indexing
Replication
Replication

What is a Majority?
If your set consists of...
1 server, 1 server is a majority.
2 servers, 2 servers are a majority.
3 servers, 2 servers are a majority.
4 servers, 3 servers are a majority.
...

Setup
To initialize a three-node replica set including one arbiter, start three mongod
instances, each using the --replSet flag followed by a name for the replica set.
For example:
mongod --replSet cluster-foo

Next, connect to one of the mongod instances and run the following:
rs.initiate()
rs.add(“host2:27017”)
rs.add(“host3:27017”, true)

rs.add() can also accept a document parameter, such as rs.add({“_id”: 4,

“host”: “host4:27017”}). The document can contain the following options:

Members will be elected primary in order

of priority, if possible. Higher values make a
priority: n member more eligible to become a primary.
n=0 means this member will never be a
primary.

Assigns a member voting privileges (n=1

votes: n
for voting, n=0 for nonvoting).

This member will always be a secondary

slaveDelay: n
and will lag n seconds behind the master.
Setup (continued)

arbiterOnly: true This member will be an arbiter.

Do not show this member in isMaster

hidden: true output. Use this option to hide this member
from clients.
Member location description.
tags: [...] See docs.mongodb.org/manual/data-
center-awareness.

Administration

rs.initiate() Creates a new replica set with one member.

rs.add(“host:port”) Adds a member.

rs.addArb(“host:port”) Adds an arbiter.

rs.remove(“host:port”) Removes a member.

Returns a document with information about the state of

rs.status()
the replica set.

rs.conf() Returns the replica set configuration document.

Re-configures a replica set by applying a new replica

rs.reconfig(newConfig)
set configuration object.

rs.isMaster() Indicates which member is primary.

Forces the primary to become a secondary for n

rs.stepDown(n)
seconds, during which time an election can take place.

Replication
Administration (continued)

Prevents the current member from seeking election as

rs.freeze(n)
primary for n seconds. n=0 means unfreeze.

rs.printSlaveReplicatio Prints a report of the status of the replica set from the
nInfo() perspective of the secondaries.

For More Information

http://docs.mongodb.org/master/core/replication-introduction/

Replication
Sharding
Sharding

sh.enableSharding( ‘products’) Enables sharding on products database.

Shards collection catalog of products

sh.shardCollection( ‘products.
database with shard key consisting of the
catalog’, { sku:1, brand:1})
sku and brand fields.

Prints a formatted report of the sharding

sh.status() configuration and the information regarding
existing chunks in a sharded cluster.

sh.addShard( ‘REPLICA1/ Adds existing replica set REPLICA1 as a

host:27017’) shard to the cluster.

For More Information

http://docs.mongodb.org/master/core/sharding-introduction/
Mapping SQL to
MongoDB
Mapping SQL to MongoDB
Converting to MongoDB Terms

MYSQL Executable Oracle Executable MongoDB Executable

mysqld oracle mongod

mysql sqlplus mongo

SQL Term MongoDB Term

database (schema) database

table collection

index index

row document

column field

joining linking & embedding

partition shard
Queries and other operations in MongoDB are represented as documents passed
to find()and other methods. Below are examples of SQL statements and the
analogous statements in MongoDB JavaScript shell syntax.

SQL MongoDB

CREATE TABLE users (name

db.createCollection(“users”)
VARCHAR(128), age NUMBER)

INSERT INTO users VALUES db.users.insert({name: “Bob”,

(‘Bob’, 32) age: 32})

SELECT * FROM users db.users.find()

db.users.find({}, {name: 1,
SELECT name, age FROM users
age: 1, _id:0})

SELECT name, age FROM users db.users.find({age: 33}, {name:

WHERE age = 33 1, age: 1, _id:0})

SELECT * FROM users WHERE age

db.users.find({age: {$gt: 33}})
> 33

SELECT * FROM users WHERE age db.users.find({age: {$lte:

<= 33 33}})

SELECT * FROM users WHERE age > db.users.find({age: {$gt: 33,

33 AND age < 40 $lt: 40}})

SELECT * FROM users WHERE age = db.users.find({age: 32, name:

32 AND name = ‘Bob’ “Bob”})

SELECT * FROM users WHERE age = db.users.find({$or:[{age:33},

33 OR name = ‘Bob’ {name:“Bob”}]})

SELECT * FROM users WHERE age = db.users.find({age: 33}).

33 ORDER BY name ASC sort({name: 1})

SELECT * FROM users ORDER BY

db.users.find().sort({name:
name DESC
-1})

SELECT * FROM users WHERE name

db.users.find({name: /Joe/})
LIKE ‘%Joe%’

Mapping SQL to MongoDB

SQL MongoDB

SELECT * FROM users WHERE name

db.users.find({name: /^Joe/})
LIKE ‘Joe%’

SELECT * FROM users LIMIT 10 db.users.find().skip(20).lim-

SKIP 20 it(10)

SELECT * FROM users LIMIT 1 db.users.findOne()

SELECT DISTINCT name FROM users db.users.distinct(“name”)

SELECT COUNT(*) FROM users db.users.count()

SELECT COUNT(*) FROM users db.users.find({age: {$gt:

WHERE AGE > 30 30}}).count()

db.users.find({age: {$exists:
SELECT COUNT(AGE) FROM users
true}}).count()

db.users.update({name: “Bob”},
UPDATE users SET age = 33 WHERE
{$set: {age: 33}}, {multi:
name = ‘Bob’
true})
db.users.update({name: “Bob”},
UPDATE users SET age = age + 2
{$inc: {age: 2}}, {multi:
WHERE name = ‘Bob’
true})

DELETE FROM users WHERE name =

db.users.remove({name: “Bob”})
‘Bob’

CREATE INDEX ON users (name

db.users.createIndex({name: 1})
ASC)

CREATE INDEX ON users (name db.users.createIndex({name: 1,

ASC, age DESC) age: -1})

db.users.find({age: 32}).ex-
plain()
EXPLAIN SELECT * FROM users
WHERE age = 32
(db.users.explain().find({age:
32}) for 3.0)
db.users.aggregate( [ {$group:
SELECT age, SUM(1) AS counter
{‘_id’: ‘$age’, counter:
FROM users GROUP BY age
{$sum:1}} } ])

Mapping SQL to MongoDB

SQL MongoDB

db.users.aggregate([
SELECT age, SUM(1) AS counter {$match: {country: ‘US’} },
FROM users WHERE country = “US” {$group: {‘_id’: ‘$age’,
GROUP BY age counter: {$sum:1}} }
])
db.users.aggregate( [
SELECT age AS “how_old” FROM {$project: {“how_old”:
users “$age”}}
])

For More Information

http://docs.mongodb.org/manual/reference/sql-comparison/

Mapping SQL to MongoDB

Resources
Learn
Downloads - mongodb.org/downloads
MongoDB Enterprise Advanced - mongodb.com/enterprise
MongoDB Manual - docs.mongodb.org
Free Online Education - university.mongodb.com
Presentations - mongodb.com/presentations
In-person Training - university.mongodb.com/training

Support
Stack Overflow - stackoverflow.com/questions/tagged/mongodb
Google Group - groups.google.com/group/mongodb-user
Bug Tracking - jira.mongodb.org
Commercial Support - mongodb.com/support

Community
MongoDB User Groups (MUGs) - mongodb.com/user-groups
MongoDB Events - mongodb.com/events

Social
Twitter - @MongoDB, @MongoDB_Inc
Facebook - facebook.com/mongodb
LinkedIn - linkedin.com/groups/MongoDB-2340731

Contact
Contact MongoDB - mongodb.com/contact

©2015 MongoDB Inc.

For more information or to download MongoDB, visit mongodb.org