Getting Started With MongoDB and Mongoose

Getting Started WithMongoDB{ author: “Ynon Perek” }

Thursday, January 31, 13

Whoami

Ynon Perek

http://ynonperek.com

[email protected]




mailto:[email protected]

mailto:[email protected]

Agenda

MongoDB Overview

Mongo Test Drive

Mongo Data Model

CRUD Operations

Working With Files


MongoDB Overview

Data Store for JSON Objects


MongoDB Overview

Data Store for JSON Objects

{ “Name” : “Rose Tyler” }


JSON Objects

A JSON Object is a collection of key/value pairs

Keys are simple strings

Values can be: Numbers, Strings, Arrays, Other Objects, and more


JSON Examples

{ “name”: “The Doctor”, “age”: 900 }

{ “race”: “human”, “body parts” : [“head”, “legs”, “arms”, “eyes”]}


MongoDB Overview

A Document Oriented Database (No SQL)


Keeping It Simple


Keeping It Simple

No Transactions

No Joins


Application Architecture

DBSERVER


Application Architecture

DBSERVER

DB

DB


What Can Mongo Do For You

Create and store objects

Arrange them in collections

Retrieve them later


Q & A


Mongo Test DriveCreate MongoLab Account And Start Using The DB


Install mongo Client

Download mongo from:http://www.mongodb.org/downloads

Extract zip file

Run mongo


http://www.mongodb.org/downloads

http://www.mongodb.org/downloads


Choose production release for your architecture



Note: Still using Windows XP ? You’ll have to use the previous 2.0 version


Meet MongoLab


Database Dashboard


Create New Database

Choose database name

Choose provider

Choose plan (free is good)

Create a DB user


Database Dashboard


Connecting To The DB

There are two options to work with your new DB

You can use the web console

You can use the command line console

Let’s start with the web.


Demo: Creating Documents

Create a few documents on the web console

Update the data

Delete some of them

Search by fields


Mongo Data Model

Let’s model A blog post in a blog app

What’s The Data ?

How Should You Save It ?


Cool MongoDB Design

{“title”: “Mongo 101”,“author” : “ynonp”,“comments” : [ { “author” : “...”, “content” : “...” }, { “author” : “...”, “content” : “...” }],“tags” : [ “funny”, “informative”],“content” : “...”

}


Q & A


Lab

Create a DB for musical info

Create a collection called albums

Add info for 3 albums you like, including:

Album Name, Artist, Tracks, Release Date, Genres

Tracks is an array of objects

Genres is an array of strings


CRUD OperationsCreate, Read, Update and Destroy Data


Mongo CRUD

Create is called insert

Read is called find

Update is called update

Destroy is called remove


Mongo CRUD

From a developer’s perspective, MongoDB operations are the same through the driver and through the console

In both cases, operations look like function calls or method invocations

We’ll use mongo shell for the rest of this chapter


Inserting Data

Use the command insert or save to insert a new object

db.collection.insert( obj );

db.collection.insert( array );


Inserting Data

Inserting to a new collection creates the collection

Inserting an object with an _id key, it is used as the object’s id (and must be unique).


find and findOne perform read operations

Both take a query

find returns a cursor

findOne returns an object

db.collection.find( <query>, <projection> )

Reading Data

Optional: Fields to fetch


Query Document

An empty (or missing) query document returns everything

db.collection.find({})

db.collection.find()


Query Document

Each key/value pair in the query document imposes a condition on the results (objects that match).

db.movies.find({ “genre” : “indie” });

db.books.find({“pages” : { “$gt” : 100 }});


Query Document

Each key/value pair in the query document imposes a condition on the results (objects that match).

db.movies.find({ “genre” : “indie” });

db.books.find({“pages” : { “$gt” : 100 }});

Query Object


Query Document

A compound query means a logical AND on the conditions.

db.inventory.find( { “type” : “snacks”, “available” : { “$lt” : 10 } });


Quiz: What Is Returned

{ “publisher” : “DC”}

from alterego publisher

Earth Bruce Wayne DC

Earth Peter Parker Marvel

Krypton Clark Kent DC


Quiz: What Is Returned

{ “publisher” : “DC”, “from” : “Earth”}

from alterego publisher

Earth Bruce Wayne DC

Earth Peter Parker Marvel

Krypton Clark Kent DC


More Queries

You can use “$or” to have an OR expression

{ “$or” : [ { “type” : “food” }, { “type” : “drinks” } ]}


Sub Documents

If your document has sub-documents, it’s possible to query by a full sub document or look for a partial match

Full sub-document query means subdocument is exactly as specified in the query

Example:

{ ISBN : { “ISBN-10” : “1906465592”, “ISBN-13” : “978-1906465599” }}


Sub Documents

A partial query matches all objects that have at least the required field (but may contain more)

Example:{ “language.primary” : “english”}

Value of language is an object, and it has a field called primary


Arrays

You can use an exact array match by providing the full array in the query

Example:{ tags : [ “funny”, “cute”, “cats” ]}


Arrays

You can query for an array that has at least one element matching the query

Example:

{ “tags” : “funny” }


Arrays

If you have a subdocument as the element of an array, it’s possible to query by its fields using the dot notation.

Examples:

{ “tracks.4.name” : “Rose Mary Stretch” }

{ “tracks.name” : “Rose Mary Stretch” }


Query Operators

Complex queries are performed with special operators.

These are reserved words starting with a $

Some of them: $gt, $gte, $lt, $lte, $ne, $in, $nin, $all, $or, $not


Comparator Queries

Value for key a is greater than 10{ “a” : { “$gt” : 10 }}

Value for key b is not 7{ “b” : { “$ne” : 7 }}

Value for key name is greater (dictionary sort) than ‘bird’{ “name” : { “$gt” : “bird” }}


Queries: $in, $nin

Use $in to specify a choice from multiple options

Value for grade is 85, 90 or 100{ “grade” : { “$in” : [ 85, 90, 100 ] } }

Value for fruit is neither apple nor banana{ “fruit” : { “$nin” : [“apple”, “banana” ] } }


Quiz: What Is Selected

{ “reads” : { “$gt” : 10 }, “author” : { “$nin” : [“admin”, “manager”, “boss” ] } }

author reads title

admin 99 How To Use Mongo

Joe 120 How To Make Money

Jim 8 Windows Manual


Queries: $all

Select objects with array containing all elements

Example:{ “tags” : { “$all” : [ “funny”, “cats” ] } }


More Query Operators

“$size” - array has a specific number of elements

“$exists” - field present or missing

Example:

{ “friends” : { “$size” : 7 } }

{ “producer” : { “$exists” : false } }


Aggregation

count() - returns how many objects found

distinct() - returns all distinct values for a key

Example:

db.posts.distinct( “tags” )


Resources

Queries Cheat Sheethttp://www.10gen.com/sites/default/files/downloads/mongodb_qrc_queries.pdf


http://www.10gen.com/sites/default/files/downloads/mongodb_qrc_queries.pdf




Q & A


Lab

Using the previously defined musical DB. Query for:

Albums released after/before 2008

Albums with 7 tracks

Albums by a specific genre

Albums by a specific track name

Display ALL different genres in the DB


Update

Update operations modify existing data in the DB

Mongo supports two update commands: update() and save()

Update is the more general (and complex)


Update

The general form for update is:

db.collection.update( <query>, <update>, <options> )

Which Entries to update

What to do with them


Update

The second argument to update() is an operator object

It tells update what to do with the data

Some keys you can use: “$set”, “$inc” “$push”, “$pushAll”, “$addToSet”, “$pop”, “$pull”, “$pullAll”


Update: set

$set modifies a value or add a new value

Example:

db.posts.update( { title: “Why Is Your Cat Unhappy” }, { $set : { “archived” : true } });


Quiz: $set

What happens here ?

db.cats.update( { color: “white” }, { “$set” : { “owners” : [“John”, “Jim”] } });


Quiz: $set

Update owners array of the first cat with white color

If you want to update all objects, use multi

db.cats.update( { color: “white” }, { “$set” : { “owners” : [“John”, “Jim”] } } { multi : true });


Update: inc

$inc increases a numeric value

Example:

{ “$inc” : { “age” : 11 } }


Quiz: $inc

What happens here ?

db.songs.update( { “title” : “Killing Lies” }, { “$inc” : { “plays” : 1 } });


Update: push and pushAll

push() and pushAll() add items to an existing array

If they array did not exists, it is created

Example:

db.creatures.update( { name: “The Doctor” }, { “$push” : { companions : “Rose Tyler” } })


Update: addToSet

The $addToSet adds a new item only if it wasn’t already in the array

Example:

{ “$addToSet” : { “tags” : “funny” } }


Update: pop

pop removes items of an array

Use a value of 1 to remove the last element

Use a value of -1 to remove the first element

Example:

{ “$pop” : { “companions” : 1 } }


Update: pull

Remove a specific item from an array.

Can use $pullAll to remove all matching elements

Example:

{ “$pull” : { “companions” : “Rose Tyler” } }


Updating with save()

The second update operation is save()

takes a document:

If the document has an id - update it

If not, insert it to the DB


Deleting Data

remove() deletes objects from a collection

Takes a query and possibly a <justOne> arguments

Examples:

db.posts.remove({ “author” : “Father Angelo” })

db.music.remove({ “genres” : “pop” })

db.posts.remove({ “tags” : “funny” }, 1 );


Q & A


Lab

From the previous music database:

Add a new album with 4 tracks

Add a new track to that new album

Set property “plays” on all albums to 6

Increase it by 4 only for “indie” albums

Delete all “indie” music


MongooseMongoDB + Node.JS


What’s That

An Object Relational Mapper for Node.JS

Handles gory details so you don’t have to

Fat Models


Agenda

Hello Mongoose

Schema and Data Types

Custom Validators

Querying Data

Poor Man’s Joins (Populate)

Mongoose Plugins


Online Resources

http://mongoosejs.com/

https://github.com/LearnBoost/mongoose

http://www.youtube.com/watch?v=4fQsDiioj3I

irc: #mongoosejs on freenode


http://mongoosejs.com

http://mongoosejs.com





Hello Mongoose

var mongoose = require('mongoose');mongoose.connect('localhost', 'test');

var schema = mongoose.Schema({ name: 'string' });var Cat = mongoose.model('Cat', schema);

var kitty = new Cat({ name: 'Zildjian' });kitty.save(function (err) { if (err) // ... console.log('meow');});


Mongoose Objects

Schema

Model Model

Schema

Model


Mongoose Objects

{ name: String}

Cat

kitty

var mongoose = require('mongoose');mongoose.connect('localhost', 'test');

var schema = mongoose.Schema( { name: 'string' });

var Cat = mongoose.model( 'Cat', schema);

var kitty = new Cat( { name: 'Zildjian' });


Schema Definitions

A schema takes a description object which specifies its keys and their types

Types are mostly normal JS

new Schema({ title: String, body: String, date: Date, hidden: Boolean, meta: { votes: Number, favs: Number }});


Schema Types

String

Number

Date

Buffer

Boolean

Mixed

ObjectId

Array


Nested Objects

Creating nested objects is easy

Just assign an object as the value

var PersonSchema = new Schema({ name: { first: String, last: String }});


Array Fields

Array fields are easy

Just write the type as a single array element

var PersonSchema = new Schema({ name: { first: String, last: String }, hobbies: [String]});


Schema Use Case

Let’s start writing a photo taking app

Each photo is saved in the DB as a Data URL

Along with the photo we’ll save the username

var PhotoSchema = new Schema({ username: String, photo: String, uploaded_at: Date}); var Photo = mongoose.model( 'Photo', PhotoSchema);


Creating New Objects

Create a new object by instantiating the model

Pass the values to the ctor

var mypic = new Photo({ username: 'ynon', photo: 'foo', uploaded_at: new Date()});


Creating New Objects

After the object is ready, simply save it mypic.save();


What Schema Can Do For You

Add validations on the fields

Stock validators: required, min, max

Can also create custom validators

Validation happens on save

var PhotoSchema = new Schema({ username: { type: String, required: true }, photo: { type: String, required: true },

uploaded_at: Date});



Provide default values for fields

Can use a function as default for delayed evaluation

var PhotoSchema = new Schema({ username: { type: String, required: true }, photo: { type: String, required: true }, uploaded_at: { type: Date, default: Date.now }});



Add methods to your documents

var EvilZombieSchema = new Schema({ name: String, brainz: { type: Number, default: 0 }}); EvilZombieSchema.methods.eat_brain = function() { this.brainz += 1;};


Custom Validators

It’s possible to use your own validation code

var toySchema = new Schema({ color: String, name: String}); toySchema.path('color').validate(function(value) { return ( this.color.length % 3 === 0 );});


Schema Create Indices

A schema can have some fields marked as “index”. The collection will be indexed by them automatically

var PhotoSchema = new Schema({ username: { type: String, required: true, index: true }, photo: { type: String, required: true }, uploaded_at: { type: Date, default: Date.now }});


Schemas Create Accessors

A virtual field is not saved in the DB, but calculated from existing fields. “full-name” is an example.

personSchema.virtual('name.full').get(function () { return this.name.first + ' ' + this.name.last;});

personSchema.virtual('name.full').set(function (name) { var split = name.split(' '); this.name.first = split[0]; this.name.last = split[1];});


Q & A


Querying Data

Use Model#find / Model#findOne to query data

// executes immediately, passing results to callbackMyModel.find({ name: 'john', age: { $gte: 18 }}, function (err, docs) { // do something with data // or handle err});


Querying Data

You can also chain queries by not passing a callback

Pass the callback at the end using exec

var p = Photo.find({username: 'ynon'}). skip(10). limit(5). exec(function(err, docs) { console.dir( docs );});


Other Query Methods

find( cond, [fields], [options], [cb] )

findOne ( cond, [fields], [options], [cb] )

findById ( id, [fields], [options], [cb] )

findOneAndUpdate( cond, [update], [options], [cb] )

findOneAndRemove( cond, [options], [cb] )


Counting Matches

Use count to discover how many matching documents are in the DB

Adventure.count({ type: 'jungle' }, function (err, count) { if (err) .. console.log('there are %d jungle adventures', count);});


Lab

Create a Schema called “Album”

Add fields: artist, year, tracks

Create a model and a document

Add validator for year

Save it in the DB


Lab

Create 5 albums from years 2008, 2009, 2010, 2011, 2012

Query the 3 newest albums

Print the artist name and the number of tracks

Print the artist who has the most albums


Populating Collections

Mongo has no joins

Let’s Fake Them


Start With Relationships

Execute the following to create an initial relationshiphttps://gist.github.com/4657446

Watch the data in the DB:

Album.artist = ObjectId("5106b6e6fde8310000000001")


https://gist.github.com/4657446


Use Query#populate

query#populate sends another query for the related object

Album.findOne().exec(function(err, doc) { // prints undefined console.log( doc.artist.name );}); Album.findOne().populate('artist').exec(function(err, doc) { // prints Pink Floyd console.log( doc.artist.name );});


Use Query#populate

Full method signature:

Query#populate( path, [fields], [model], [cond], [options] )

cond is a query condition object ( i.e. { age: { $gte: 21 }}

options is a query options object ( i.e. { limit: 5 }

Helps when populating arrays


Mongoose Plugins

A plugin connects to the Schema and extends it in a way


Mongoose Plugins

A mongoose plugin is a simple function which takes schema and options

Demo: lastModifiedPluginhttps://gist.github.com/4657579




Mongoose Plugins

find or create plugin:

https://github.com/drudge/mongoose-findorcreate




Mongoose Plugins

Hashed password field plugin:https://gist.github.com/4658951




Mongoose Plugins

Mongoose troops is a collection of useful mongoose plugins:https://github.com/tblobaum/mongoose-troop


https://github.com/tblobaum/mongoose-troop

https://github.com/tblobaum/mongoose-troop

Thank You

Photos from: http://123rf.com

Slides available at: http://ynonperek.com


http://123rf.com

http://123rf.com



Technology

Getting Started With MongoDB and Mongoose