A few noteworthy changes.

1. PDO now throws exceptions by default. The standard default in PDO is to fail silently. This was unintended and thanks to @jimplush for reporting it. Be sure to try/catch your code appropriately.
2. Db::execute() method added. All of the Db methods are publicly accessible and this method is for executing sql that doesn’t require a fetch (inserts, updates, deletes, etc). The requirement for this method became clear after turning on exceptions in PDO.
3. Better docs. The docs in the README have been updated and reformatted.

DumbledORM received a lot of great feedback and attention after it’s release. Thank you for all the positive response to this little ORM. I hope it continues to grow in use and remains small in size.

Download DumbledORM and get started here:
https://github.com/jasonmoo/DumbledORM

MacPorts. If you’re not already familiar with it, I recommend reading up before proceeding.

Since I already have MySQL set up and configured I won’t bother covering it here. It’s pretty well documented around the webs. The main focus here is going to be getting nginx installed and setting up PHP as a service to it with an emphasis on local development. No need to tweak this for production on my Macbook Pro.

PHP 5.3.3 introduced PHP-FPM (FastCGI Process Manager) to the codebase. Building it requires a few extra config flags and generates a php-fpm binary. The binary will manage spawning cgi processes and handling the FastCGI passthru from nginx. Currently MacPorts does not have an option to build PHP with PHP-FPM. After some hacking on the current Portfile I arrived at a working solution. It includes the correct flags, a dependency on libevent, and a startup item.

First things first.

sudo port selfupdate

# recommended but probably not a requirement
sudo port upgrade outdated
sudo port uninstall inactive

(If you’ve already got the php5 package installed, uninstall it and it’s cohorts to ensure a clean install process going forward.)

This is a bit of a hack and there’s probably a better way, like submitting a proper patch to MacPorts, but this will get the job done for today.

# replace this file with the Portfile from the gist below
/opt/local/var/macports/sources/rsync.macports.org/release/ports/lang/php5/Portfile

https://gist.github.com/724449

Then run the regular port install.

sudo port install nginx php5 +fastcgi php5-apc php5-mysql +mysqlnd

Next we’ll need to set up the configs. There’s two basic configs that require attention. First is the nginx config. Since this is just for a local development env we can be pretty lean on what we need.

# /opt/local/etc/nginx/nginx.conf

worker_processes  1;

error_log  /var/log/nginx/error.log;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    sendfile           on;
    keepalive_timeout  65;

    server {
      listen 80;
      server_name   ~^local\.(?.+?)\.com$;
      root  /Users/jason/Sites/$site/web;
      index  index.php index.html;

      location = /favicon.ico {
        log_not_found off;
      }

      location ~ \.php$ {
         fastcgi_pass   unix:/tmp/php-fpm.sock;
         fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
         include        fastcgi_params;
      }
    }
}

This is the config that I’m currently using as my generic site config. It has a few nice features. First the server name is matched against a regular expression. So any site that matches local.xxxx.com will be parsed and use the xxxx as a sub-directory in my Sites folder. This is nice. So I only need to create a new directory and add my local.xxxx.com domain to /etc/hosts pointed at 127.0.0.1 and I can immediately begin developing. Gone are the days of creating a new v-hosts file, enabling it, and restarting apache every time I want to play with a new site’s code. The other nicety here is we’re using a unix socket for the fastcgi passthru. This is unnoticeably faster on my Mac, but again frees up the need to be concerned with another open port on my system.

It’s worth noting that any fastcgi_param that you define in this config is available within PHP as a $_SERVER variable.

The second config is the FPM config. Copy /opt/local/etc/php-fpm.conf.default to /opt/local/etc/php-fpm.conf and open it up. Here are the important ones to modify:

pid = /opt/local/var/run/php-fpm.pid
error_log = /opt/local/var/log/php-fpm.log
listen = /tmp/php-fpm.sock
listen.owner = _www
listen.group = _www
pm.max_children = 1
pm.start_servers = 1
pm.min_spare_servers = 1
pm.max_spare_servers = 1
pm.max_requests = 500
slowlog = /opt/local/var/log/php-fpm.log.slow

It’s pretty straight-forward. Lean cus we can. Save and continue.

At this point we’ve got all the pieces in place. We just need a way to start/stop/restart nginx and FPM. I looked for a cleaner way to accomplish this but in the end it came down to a handful of aliases. Add these to your ~/.profile.

# nginx
alias nginx_start='sudo launchctl load /Library/LaunchDaemons/org.macports.nginx.plist'
alias nginx_stop='sudo launchctl unload /Library/LaunchDaemons/org.macports.nginx.plist'
alias nginx_restart='nginx_stop; nginx_start;' 

# php-fpm
alias fpm_start='sudo launchctl load /Library/LaunchDaemons/org.macports.php-fpm.plist'
alias fpm_stop='sudo launchctl unload /Library/LaunchDaemons/org.macports.php-fpm.plist'
alias fpm_restart='fpm_stop; fpm_start'

Reopen the Terminal window to enable the new aliases. Start or restart nginx and FPM as the case may be.

At this point you should be able to create a site directory, add a domain to /etc/hosts and drop in an index.php with phpinfo(); to verify that PHP is working.

Hopefully this will be of some use to other aspiring MEMP devs out there. I found it intensely fun.

Some examples of what it can do:

// load record with id 13
$user = new User(13);
$user->setName('Jason')->save();

// create new record
$user = new User(array(
  'name' => 'Jason',
  'email' => 'jasonmoo@me.com',
));
$user->save();

// find single record
User::one(array('name' => 'Jason'))->delete();

// apply object methods to entire set at once
PhoneNumber::select('`number` like "607%"')
  ->setLocation('Ithaca, NY')
  ->save();

// relations between objects
$user->create(new PhoneNumber(array(
  'type' => 'home',
  'number' => '607-333-2840',
)))->save();

// update all user phone numbers matching $type
$user->getPhoneNumber('`type` = ?',$type)
  ->setType($new_type)
  ->save();

Applying model object methods to entire sets of objects, jQuery style, is made possible by this incantation:

final class ResultSet extends ArrayIterator {
  public function __call($method,$params=array()) {
    foreach ($this as $obj) {
      call_user_func_array(array($obj,$method),$params);
    }
    return $this;
  }
}

So proud. I hope you find it fun and maybe even useful. Although at this point all I can say is that it’s passing it’s little tests.

So now let’s see how MongoDB holds up against MySQL in the simple query arena.

Simple Queries

For our purposes here we’ll only use the fastest setup and we’ll vary the query parameters for different results. When I set up this test system I actually used a yaml schema so that we could test Doctrine. I had to abandon that in the insert tests, but here it should work fine.

Total Record Count
Mongo:

echo $mongo->selectDb('objects')->selectCollection('users')->count();

The response time was 25ms (only 1ms over Symfony’s overhead).

MyISAM with Doctrine ORM:

echo Doctrine_Query::create()->from('User u')->count();

The response time was 30ms (only 5ms over Symfony’s overhead).

InnoDB with Doctrine ORM:

echo Doctrine_Query::create()->from('User u')->count();

The response time was 916ms..

Unindexed query

Mongo:

$query = array(
  'pet' => 'sugar glider',
);
echo $users->find($query)->count();

This returns a count of 500k and after several tests the average response time was 950ms.

MyISAM with Doctrine ORM:

$users = Doctrine_Query::create()
   ->from('User u')
   ->where('u.pet = "sugar glider"');
echo $users->count();

This returns a count of 500k and after several tests the average response time was 870ms.

InnoDB with Doctrine ORM:

$users = Doctrine_Query::create()
   ->from('User u')
   ->where('u.pet = "sugar glider"');
echo $users->count();

This returns a count of 500k and after several tests the average response time was 1300ms.

Indexed query
Mongo:

$query = array(
  'number' => 1005,
);
echo $users->find($query)->count();

This returns a count of 250 in 25ms.

MyISAM with Doctrine ORM:

$users = Doctrine_Query::create()
   ->from('User u')
   ->where('u.onumber = 1005');
echo $users->count();

This returns a count of 250 in 30ms.

InnoDB with Doctrine ORM:

$users = Doctrine_Query::create()
   ->from('User u')
   ->where('u.onumber = 1005');
echo $users->count();

This returns a count of 250 in 30ms.

Indexed range query
Mongo:

$query = array(
  'number' => array('$gt'=>1000,'$lt'=>1005),
);
echo $users->find($query)->count();

This returns a count of 1,000 in 26ms.

MyISAM with Doctrine ORM:

$users = Doctrine_Query::create()
   ->from('User u')
   ->where('u.onumber between 1001 and 1004');
echo $users->count();

This returns a count of 1,000 in 32ms.

InnoDB with Doctrine ORM:

$users = Doctrine_Query::create()
   ->from('User u')
   ->where('u.onumber between 1001 and 1004');
echo $users->count();

This returns a count of 1,000 in 31ms.

Indexed range query (large set)
Mongo:

$query = array(
  'number' => array('$gt'=>1000,'$lt'=>9005),
);
echo $users->find($query)->count();

This returns a count of 2,001,000 in 2.5 seconds.

MyISAM with Doctrine ORM:

$users = Doctrine_Query::create()
   ->from('User u')
   ->where('u.onumber between 1001 and 9004');
echo $users->count();

This returns a count of 2,001,000 in 1.5 seconds.

InnoDB with Doctrine ORM:

$users = Doctrine_Query::create()
   ->from('User u')
   ->where('u.onumber between 1001 and 9004');
echo $users->count();

This returns a count of 2,001,000 in 760ms.

Indexed range query, ordered, limit 10, with output
Mongo:

$query = array(
  'number' => array('$gt'=>1000,'$lt'=>9005),
);
$sort = array(
  'number' => -1,
);
foreach ($users->find($query)->sort($sort)->limit(10) as $user)
{
  echo $user['_id'],':',$user['number'],'
';
}

This returns in 26ms.

MyISAM with Doctrine ORM:

$users = Doctrine_Query::create()
   ->from('User u')
   ->where('u.onumber between 1001 and 9004')
   ->orderBy('u.onumber desc')
   ->limit(10);
foreach ($users->execute() as $user)
{
  echo $user->getId(),':',$user->getOnumber(),'
';
}

This returns in 35ms.

InnoDB with Doctrine ORM:

$users = Doctrine_Query::create()
   ->from('User u')
   ->where('u.onumber between 1001 and 9004')
   ->orderBy('u.onumber desc')
   ->limit(10);
foreach ($users->execute() as $user)
{
  echo $user->getId(),':',$user->getOnumber(),'
';
}

This returns in 34ms.

Well we’ve got a lot of interesting numbers here. Seems as though MongoDB has a little trouble with large set range searches, and unindexed queries, but kicks butt in the other tests. And InnoDB seems to handle the large ranged queries the best with a modest showing in the rest, except for total record count.. Wth happened there? And MyISAM seems to be a pretty speedy running mate for everything, with an edge on the unindexed queries.

Real world value of these tests? I would have liked to run even more extensive queries here, but wanted to make sure I saved time for the next section which covers relations. But a decent real world example would be that last test. And MongoDB seems to have almost a 10ms edge on MySQL when it comes to this.

I realize that these results are not accounting for the overhead of using Doctrine. And I’m ok with that because I’m interested in real development environment stuff, not so much what is the bare bones potential. And so far MongoDB is doing well, although, the features of Doctrine would largely be missing from a MongoDB setup until we get a good framework that can sit on top of a MongoDB (which might even out the scores in many of these queries).

In the next section we’ll try to see how we can use MongoDB to persist relations between objects using their MongoDBRef class and a little forethought..

System Setup
Some VPS setup with 1and1.com with a gig of dedicated ram
Ubuntu 8.04.1 64bit Hardy
Symfony 1.2.9 dev updated repository
MongoDB Linux 64 0.9.9 (mongodb-linux-x86_64-0.9.9.tgz)
Doctrine 1.0.10 (bundled with Symfony)
Apache 2.2.8
PHP 5.3.0 with mysqlnd
MySQL 5.4 with the my.cnf for medium systems
PECL MongoDB package 0.9.4

What is it? That was my first thought. A quick review of their site gave me a taste of something that sounded good. I’ve been working with Symfony and Doctrine for almost a year now and really loving it. Started writing a custom orm for my current employer and found that it really brought to light some issues with relational modeling. For instance, free-form relations between objects. In a RDBMS you’ve got to setup your long table with key/val pairs that reference other tables and ids and then there’s the whole issue of efficiently joining on that. I found that trying to translate that structure into an orm style development tool was challenging to say the least. I wondered if a DODB would offer a better way. Ideally the speed of development AND the speed of the data manipulation would increase. MongoDB has a nice little DBRef class that allows you to reference your way around your collections, effectively hardcoding your joins at the data level. Would it be a nice way to handle creating relationships between objects without premeditation?

Setup

Ok so I wanted to set up some simple benchmarks just to see what we were looking at as far as ease of use and speed for basic dumb things. I setup a basic Symfony/Doctrine project and pulled down the latest version of MongoDB for Linux 64.

I started my mongod server without the web interface since I won’t need it for this:

mongod --dbpath=/var/www/sites/mongobjects/web/data/mongodb/ --nohttpinterface --quiet &
Sun Aug 23 04:09:56 Mongo DB : starting : pid = 11534 port = 27017 dbpath = /var/www/sites/mongobjects/web/data/mongodb/ master = 0 slave = 0  64-bit
Sun Aug 23 04:09:56 db version v0.9.9, pdfile version 4.4
Sun Aug 23 04:09:56 git version: cd0bf23e74ef8ded0684f74996ee762889b93294
Sun Aug 23 04:09:56 sys info: Linux ofc-n1.10gen.com 2.6.23.17-88.fc7 #1 SMP Thu May 15 00:02:29 EDT 2008 x86_64
Sun Aug 23 04:09:56 waiting for connections on port 27017

And we’re up and running.

Filling our Databases

These tests will be run via a page load in Symfony. So all the code takes place within an actions class method that is triggered by a url and tracked via symfony’s developer bar. A simple benchmarking tool that produces a little fluctuation in the numbers, but fine for what we’re doing here. It’s worth noting that on this system Symfony takes ~24ms to render a page without anything else happening. So all our tests will have an extra ~24ms from Symfony execution time.

Mongo

I wanted a simple single table test setup so I decided to build a user set of 500,000 users. But then I realized toward the end of this article that I my 5 types of pets actually made all my tests insert 2.5 million records. So that’s what we’re using. Loading data with MongoDB was simple and quick. Just select the db and collection you want and if it’s not already in existence it will be when you start writing to it.

$mongo = new Mongo;
$users = $mongo->selectDb('objects')->selectCollection('users');
$animals = array('cat','dog','sugar glider','pigeon','dove');

for ($j=0; $j < 50; $j++)
{
  for ($i=0; $i < 10000; $i++)
  {
    foreach ($animals as $animal)
    {
      $users->save(array(
        'number' => $i,
        'pet' => $animal,
        'name' => 'Jason Mooberry',
        'email' => 'jason@barkingsnake.com',
      ));
    }
  }
}

Mongo ran through this like it was bored. Occasionally it had to create a new datafile but this was only apparent in the log.

Sun Aug 23 04:23:22 newExtent: objects.users file 0 full, adding a new file
Sun Aug 23 04:23:22 allocating new datafile /var/www/sites/mongobjects/web/data/mongodb/objects.1, filling with zeroes...
Sun Aug 23 04:23:22 done allocating datafile /var/www/sites/mongobjects/web/data/mongodb/objects.1, size: 134217728, took 0.243 secs

MongoDB uses preallocated data files to store it BSON data. Data files are created in increasingly larger sizes to handle fragmentation more efficiently.

The total insert time on 2.5 million records was 55 seconds. Let’s see how MySQL holds up.

MySQL

OK let’s see what happens when we create a simple table in MySQL and load the same 2.5 million user set. I created a simple table in Navicat:

CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) DEFAULT NULL,
`onumber` int(11) DEFAULT NULL,
`pet` varchar(255) DEFAULT NULL,
`email` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

I chose InnoDB since MySQL 5.4 is boasting some big improvements in the InnoDB engine. I realize much of that is about large scale systems with complex joins, but let’s just see how it does.

Running an insert set of this size is an impossibility with this version of Doctrine. It quickly runs out of memory. I think this might be solved by a better garbage collection method in Doctrine 2.0 or perhaps even 1.1, but not in 1.0. So we do it the old fashioned way:

$db = mysql_connect('localhost', 'mongobjects_user', 'm0ng0');
mysql_select_db('mongobjects',$db);
$animals = array('cat','dog','sugar glider','pigeon','dove');
for ($j=0; $j < 50; $j++)
{
  for ($i=0; $i < 10000; $i++)
  {
    foreach ($animals as $animal)
    {
      $qs = "insert into `user` (`onumber`,`pet`,`name`,`email`) values ($i,'$animal','Jason Mooberry','jason@barkingsnake.com')";
      mysql_query($qs);
    }
  }
}

OK so I hit the url and wait… tick tock.. tick tock.. TICK TOCKKKKK… After several minutes I peek at the insert log and see that MySQL is still diligently inserting rows. So I continue to wait and wonder what my max execution time is set at..

After having a conversation with my girlfriend about stuff, MySQL finally crosses the finish line in 18.23 minutes… I realize I have the query log on and that is a bit of a hog, so let’s rerun it with the log turned off. bin-log appears to be on as well and since we’re not replicating here, I’ll turn that off too.

I restart MySQL, truncate the table, and try again.

While I wait I’d like to pontificate on the merits of a fast file system. ReiserFS is the default system on my vps but my recent experiences with XFS have led me to believe it to be a better option… [10 mins go by] … and so that is why I think Hans Reiser is a jerk! OH um I think we’ve finished.

MySQL without the logs comes in at 9.96 minutes for inserting 2.5 million records. That’s a big difference. Maybe it’s worth checking the speed with MyISAM. I change the table to MyISAM, truncate and repeat.

Ok MyISAM puts MySQL back in the running with an insert of 2.5 million records in 2.58 minutes. I guess it’s probably a better comparison with MyISAM since MongoDB isn’t transactional and we’re not dealing with foreign key constraints. Still I was hoping for a much stronger showing from InnoDB..

EDIT: After rummaging through this article today about auto-commit transaction handling in InnoDB and PHP, I decided to give InnoDB another chance to prove it’s worth here. So I reran the insert tests inside a single transaction:

$animals = array('cat','dog','sugar glider','pigeon','dove');
$db = mysql_connect('localhost', 'mongobjects_user', 'm0ng0');
mysql_select_db('mongobjects',$db);
mysql_query('START TRANSACTION',$db);
for ($j=0; $j < 50; $j++)
{
  for ($i=0; $i < 10000; $i++)
  {
    foreach ($animals as $animal)
    {
      $qs = "insert into `user` (`onumber`,`pet`,`name`,`email`) values ($i,'$animal','Jason Mooberry','jason@barkingsnake.com')";
      mysql_query($qs,$db);
    }
  }
}
mysql_query('COMMIT',$db);

And InnoDB is back in this thing… sort of. 2.5 million rows inserted inside a single transaction: 2.45 minutes. I also reran this with the Index specified below and it ran in 3.28 minutes. Our use case may not actually involve this type of scenario so it’s of mixed value.

Indexes

Our insert tests were run without an index to slow it down. The inserted records were done in 50 batches of 10,000 batches of 5 records with a number field storing the record number within it’s batch. The end result is that the number field will match in 250 records for each number. So a nice ranged query on that column will be a good way to test our search speed. So lets add an index to our number column and rerun our inserts.

Mongo

Adding an index to a collection in MongoDB consists of a php command:

$mongo = new Mongo;
$users = $mongo->selectDb('objects')->selectCollection('users')->ensureIndex(array('number'=>1));

Seeting the key ‘number’ to 1 creates an ascending index.

I’ve gone ahead and rm’d all the mongo db files so that we get an accurate test.

$mongo = new Mongo;
$users = $mongo->selectDb('objects')->selectCollection('users');
$users->ensureIndex(array('number'=>1));
$animals = array('cat','dog','sugar glider','pigeon','dove');
for ($j=0; $j < 50; $j++)
{
  for ($i=0; $i < 10000; $i++)
  {
    foreach ($animals as $animal)
    {
      $users->save(array(
        'number' => $i,
        'pet' => $animal,
        'name' => 'Jason Mooberry',
        'email' => 'jason@barkingsnake.com',
      ));
    }
  }
}

With the index on the number column Mongo inserts 2.5 million records in 1.32 minutes. Not bad I guess. Let’s see how MySQL does.

MySQL (MyISAM)

I’m sticking with MyISAM for the rest of these tests since I don’t care to wait all day for my tests to run and the feature sets match a little better between MongoDB and MyISAM. So I’m just gonna truncate the table and add an index and rerun.

CREATE TABLE `user` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(255) CHARACTER SET latin1 DEFAULT NULL,
 `onumber` int(11) DEFAULT NULL,
 `pet` varchar(255) CHARACTER SET latin1 DEFAULT NULL,
 `email` varchar(255) CHARACTER SET latin1 DEFAULT NULL,
 PRIMARY KEY (`id`),
 KEY `user_number_idx` (`onumber`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8

PHP did not change for this test.

MySQL handles the insert with roughly the same increase at 3.02 minutes.

Insert Test Breakdown

Here’s the breakdown for our insert tests with the various flavors of MySQL and MongoDB. It’s a pretty impressive difference on massive inserts.

The winner is clear here on inserts. But let’s see how MongoDB holds up with Simple Queries, and Relations…