MongoDB and PHP ZendCon 2011

My name is
Steve Francia

@spf13

• 15+ years building the
internet

• Father, husband,
skateboarder

• Chief Solutions Architect @
10gen

• Author of upcoming O’Reilly
publication “PHP and
MongoDB”

MongoDB Goals
• OpenSource
• Designed for today
• Today’s hardware / environments
• Today’s challenges
• Easy development
• Reliable
• Scalable

• Company behind MongoDB
• AGPL license, own copyrights, engineering
team
• support, consulting, commercial license
revenue
• Management
• Google/DoubleClick, Oracle, Apple, NetApp
• Funding: Sequoia, Union Square, Flybridge
• Ofﬁces in NYC, Redwood Shores & London
• 60+ employees

1974
The relational database is created

Computers in 1995

•Pentium 100 mhz
•10base T
•16 MB ram
•200 MB HD

Cell Phones in 2011

•Dual core 1.5 Ghz
•WiFi 802.11n (300+ Mbps)
•1 GB ram
•64GB Solid State

How about a DB
designed for today?

Signs something
needed
•doubleclick - 400,000 ads/second
•caching is de rigueur
•complex ORM frameworks
•computer architecture increasing in
complexity
•cloud computing

Requirements
We need enough functionality to handle
broad set of use cases

•strong consistency / atomicity
•secondary indexes
•ad hoc queries

Trim unneeded
features
Leave out a few things so we can scale

•no choice but to leave out relational
•distributed transactions are hard to
scale

Needed a scalable
data model
Considered....

•key/value
•columnar / tabular
•document oriented (JSON inspired)

MongoDB philosphy
• Keep functionality when we can (key/
value stores are great, but we need more)
• Non-relational (no joins) makes scaling
horizontally practical
• Document data models are good
• Database technology should run
anywhere VMs, cloud or straight metal

MongoDB is:
Application Document
Oriented
{ author: “steve”,
High date: new Date(),
text: “About MongoDB...”,
Performance tags: [“tech”, “database”]}

Fully
Consistent

Horizontally Scalable

MongoDB

•JSON Documents
•Querying/Indexing/Updating similar to
relational databases
•Traditional Consistency
•Auto-Sharding

Under the hood

•Written in C++
•Available on most platforms
•Data serialized to BSON
•Extensive use of memory-mapped ﬁles

This has led
some to say

“
MongoDB has the best
features of key/ values
stores, document databases
and relational databases in
one.
John Nunemaker

CMS / Blog
Needs:
• Business needed modern data store for rapid development and
scale

Solution:
• Use PHP & MongoDB

Results:
• Real time statistics
• All data, images, etc stored together, easy access, easy
deployment, easy high availability
• No need for complex migrations
• Enabled very rapid development and growth

Photo Meta-Data
Problem:
• Business needed more ﬂexibility than Oracle could deliver

Solution:
• Use MongoDB instead of Oracle

Results:
• Developed application in one sprint cycle
• 500% cost reduction compared to Oracle
• 900% performance improvement compared to Oracle

Customer Analytics
Problem:
• Deal with massive data volume across all customer sites

Solution:
• Use MongoDB to replace Google Analytics / Omniture options

Results:
• Less than one week to build prototype and prove business case
• Rapid deployment of new features

Online Dictionary
Problem:
• MySQL could not scale to handle their 5B+ documents

Solution:
• Switched from MySQL to MongoDB

Results:
• Massive simpliﬁcation of code base
• Eliminated need for external caching system
• 20x performance improvement over MySQL

E-commerce
Problem:
• Multi-vertical E-commerce impossible to model (efﬁciently) in
RDBMS

Solution:
• Switched from MySQL to MongoDB

Results:
• Massive simpliﬁcation of code base
• Rapidly build, halving time to market (and cost)
• Eliminated need for external caching system
• 50x+ improvement over MySQL

Tons more
Pretty much if you can use a RDMBS or Key/Value
MongoDB is a great ﬁt

Relational made normalized
data look like this

Document databases make
normalized data look like this

Terminology
RDBMS Mongo
Table, View ➜ Collection
Row ➜ JSON Document
Index ➜ Index
Join ➜ Embedded Document
Partition ➜ Shard
Partition Key ➜ Shard Key

Documents to Objects
Documents to Arrays
Tables to Documents
{
PostObject Object(
[title] => MongoDB
title: ‘MongoDB’,
[contributors] => Array(
contributors: [
[0] => PersonObject Object(
{ name: ‘Eliot Horowitz’,
[name] => Eliot Horowitz
[email] => eh@10gen.com
email: ‘eh@10gen.com’ },
)
{ name: PersonObjectMerriman’,
[1] => ‘Dwight Object(
email: ‘dm@10gen.com’ }
[name] => Dwight Merriman
[email] => dm@10gen.com
],
)
model: {
)
relational: false,
[model] => ModelObject Object(
[relational] =>
awesome:=>true
[awesome] 1
})
)
}

Documents to Objects
Documents to Arrays
Tables to Documents
{ array(
PostObject Object(
title: ‘MongoDB’, "title" =>=> MongoDB
[title] 'MongoDB',
"contributors" =>=> Array(
[contributors] array(
contributors: [ array( => PersonObject Object(
[0]
{ name: ‘Eliot Horowitz’, 'name' => 'Eliot Horowitz',
[name] => Eliot Horowitz
email: ‘eh@10gen.com’ }, 'email' => 'eh@10gen.com'
[email] => eh@10gen.com
), )
{ name: ‘Dwight Merriman’, array( => PersonObject Object(
[1]
email: ‘dm@10gen.com’ } 'name' => 'Dwight Merriman',
[name] => Dwight Merriman
'email' => 'dm@10gen.com'
[email] => dm@10gen.com
],
) )
model: { ),)
relational: false, "model" =>=> ModelObject Object(
[model] array(
'relational' => false,
[relational]
awesome: true 'awesome' => true
[awesome] 1
} ) )
} )

This has led
some to say

“
The single best interface
(API) of any php
extension.
Matthew Weier O'Phinney

PHP Driver
Installing the driver

$ pecl install mongo

Add to php.ini

extension = mongo.so

Connecting to the DB

$connection = new Mongo();

$db = $connection->selectDB('blog');

$posts = $db->post;

If the DB or collection doesn’t exist,
mongoDB will create it on connect.

Documents
Blog Post Document

$p1 = array("author" => "roger",
"date" => new MongoDate(),
"text" => "about mongoDB...",
"tags" => array('tech', 'databases')
);

$posts->save($p1);

Querying
print_r($posts->findOne());
> db.posts.findOne()
Array(
[_id] => MongoId Object(
> { _id : ObjectId("4c4ba5c0672c685e5e8aabf3"),
[$id] => 4e9796764a18173a17000000
author : "roger",
)
date : "Sat Jul 24 2010 19:47:11",
[author] => roger
text : "About MongoDB...",
[date] => MongoDate Object(
tags : [ "tech", "databases" ] }
[sec] => 1318557302
[usec] => 581000
)
[text] => about mongoDB...
[tags] => Array(
Note: _id is unique, but can be anything
[0] => tech
[1] => databases
you’d like
)
)

Inserting Objects
class PostObj {
public $comments = array();
public function __construct($author, $title, $content)
{
$this->author = $author;
$this->title = $title;
$this->content = $content;
}
}

$posts->insert(new PostObj("Steve",
"My first blog post",
"Hello, World!"));

MongoId
An autogenerated primary key

$x = array("foo" => 1, "bar" => 2);
$db->baz->save($x);
var_dump($x['_id']);

Result:

object(MongoId)#4 (1) {
["$id"]=> string(24) "4e9cc76a4a1817fd21000000"
}

MongoId
An autogenerated primary key

object(MongoId)#4 (1) {
["$id"]=> string(24) "4e9cc76a4a1817fd21000000"
}

4e9cc76a4a1817fd21000000
|------||----||--||----|
ts mac pid inc

Update Operations
$set, $unset, $inc, $push, $pushAll,
$pull, $pullAll, $bit

$change = array('$push' =>
array('comments' =>
array(
'author' => 'Fred',
'created' => new MongoDate(),
'comment' => 'Best post ever!.'
)
)
);

$posts->update(array("_id" => $id), $change);

Nested Documents
Array(
{ _id : ObjectId("4c4ba5c0672c685e5e8aabf3"),
[_id] => MongoId Object (
[$id] => 4e9796764a18173a17000000
) author : "roger",
[author] => roger
date : "Sat Apr 24 2011 19:47:11",
[comments] => Array(

text : "About MongoDB...",
[0] => Array(
[author] => Fred
tags : [ "tech", "databases" ],
[created] => MongoDate Object(
[sec] => 1318899392
comments : [ [usec] => 176000
)
{
[comment] => Dumb post.
)
) author : "Fred",

[date] => MongoDate Object(
date : "Sat Apr 25 2010 20:51:03 GMT-0700",

[sec] => 1318557302
[usec] => 581000
) text : "Best Post Ever!"

[tags] => Array(

}
[0] => tech

)
]
[1] => databases

}
)
[text] => about mongoDB...

Querying

$posts = $blog->find(array(
"author" => "Roger"));

$commentsByFred = $blog->find(array(
"comments.author" => "Fred"));

$commentsByFred = $blog->find(array(
"comments.author" =>
new MongoRegex("/fred/i")));

It’s all about the $
$ instead of >, <, =, etc.

$gt, $gte, $lt, $lte, $eq, $neq, $exists,
$set, $mod, $where, $in, $nin, $inc
$push, $pull, $pop, $pushAll, $popAll

$c->find(array("x" => array('$gt' => 4)));

$c->find(array("x" => array(“$gt” => 4)));

Adjust the behavior
in php.ini or using ini_set()

php.ini
---------------
mongo.cmd = ":"

$c->find(array("x" => array(':gt' => 4)));

or

ini_set("mongo.cmd", ".");
$c->find(array("x" => array('.gt' => 4)));

Indexing
including secondary and compound
indexes

$people->ensureIndex(array("age" => 1));

$people->ensureIndex(array(
"name" => -1,
"ts" => -1,
"comments.author" => 1
));

More Indexing
// Index nested documents
$posts->ensureIndex( array("comments.author" => 1) )
$posts->find( array("comments.author" => "Fred") )

// Index on tags (multi-key index)
$posts->ensureIndex( array("tags" => 1 ) )
$posts->find( array("tags" => "tech") )

// geospatial index
$posts->ensureIndex( array("author.location" => "2d") )
$posts->find( array("author.location" =>
array( '$near' => array(22,42)));

Cursors

$cursor = $c->find(array("foo" => "bar"))

foreach ($cursor as $id => $value) {
echo "$id: ";
var_dump( $value );
}

$a = iterator_to_array($cursor);

Paging

$page_num = 3;
$results_per_page = 10;

$cursor = $results->find()
->sort(array("ts" => -1))
->skip($page_num * $results_per_page)
->limit($results_per_page);

Rich Documents
{ _id : ObjectId("4c4ba5c0672c685e5e8aabf3"),

line_items : [ { sku: ‘tt-123’,
name: ‘Coltrane: Impressions’ },
{ sku: ‘tt-457’,
name: ‘Davis: Kind of Blue’ } ],

address : { name: ‘Banker’,
street: ‘111 Main’,
zip: 10010 },

payment: { cc: 4567,
exp: Date(2011, 7, 7) },

subtotal: 2355
}

Storing Big Files

>16mb stored in 16mb chunks

Storing Big Files

Works with replicated
and sharded systems

A better network FS
• GridFS files are seamlessly sharded & replicated.
• No OS constraints...
• No file size limits
• No naming constraints
• No folder limits
• Standard across different OSs
• MongoDB automatically generate the MD5 hash
of the file

Storing Files
$grid = $db->getGridFS();

// The file's location in the File System
$path = "/tmp/";
$filename = "movie.mp4";

// Note metadata field & filename field
$storedfile = $grid->storeFile($path . $filename,
array("metadata" => array("filename" => $filename),
"filename" => $filename));

// Return newly stored file's Document ID
echo $storedfile;

Storing Data

$grid = $db->getGridFS();
$filename = "zelda.jpg";
$storedfile = $grid->storeBytes("âˆšÃ¸âˆšÃ²âˆšÃ¸âˆšâ
€ ^@^PJFIF^@ÂÂÂ,^GÊÊ^G,...",
array("metadata" => array("filename" =>
$filename),
"filename" => $filename));

Streaming Data
$gridFS = $db->getGridFS();

// Find image to stream
$image = $gridFS->findOne("zelda.jpg");

// Stream image to browser
header('Content-type: image/jpeg');
echo $image->getBytes();

Libraries & Frameworks
• Doctrine MongoDB ODM • Zend Framework
• Active Mongo • Lithium
• Mongo Queue • Symfony2
• Morph • Fuel
• Mandango • Fat Free Framework

Doctrine MongoDB ODM
• Provides full validation
• Seamless integration with Doctrine ORM
• Useful for hybrid solutions
• Follows same persistence model as Doctrine
• Uses a Document Manager & annotations
• Supports embedded and referenced objects
• Can use mongo’s query interface
• Supports in place updates
https://github.com/doctrine/mongodb-odm

Mandango
•Very light and fast
•Event support
•Supports embedded and referenced
objects
•uses the mongo query syntax
•Lacking validation, but events can be
utilized to validate
https://github.com/mandango/mandango

Active Mongo
•Uses ActiveRecord (active document)
interface
•Supports full validation
•Supports in place updating
•Uses native query interface
•Supports referenced documents
https://github.com/crodas/ActiveMongo

Morph

•Follows the Active Record model
•Has own query object (Morph_Query)
•Doesn’t provide validation
•Doesn’t support embedded or referenced
objects.

https://github.com/a-musing-moose/morph

Mongo Queue
An extensible job/message queueing system that
uses mongodb as the persistent storage engine.

• Fully Conﬁgurable
• Distributed
• Atomic Locking
• Priority Support
• Worker Timeout Support
• Stable
https://github.com/skiz/mongo_queue

http://spf13.com
http://github.com/spf13
@spf13

Questions?
download at mongodb.org
PS: We’re hiring!! Contact us at jobs@10gen.com

MongoDB and PHP ZendCon 2011

More Related Content

What's hot (19)

Viewers also liked (13)

Similar to MongoDB and PHP ZendCon 2011 (20)

More from Steven Francia (20)

Recently uploaded (20)

MongoDB and PHP ZendCon 2011

Editor's Notes