PHP and MongoDB Web Development Beginner's Guide

The NoSQL databases currently being used can be grouped into four broad categories:

Features that make learning and using MongoDB a win, include:

It is free, it can be downloaded and used without charge. It has excellent documentation and an active and co-operative online community who participate in mailing lists, forums, and IRC chat rooms.

Let's take a look at some real world use cases of MongoDB:

A MongoDB server hosts a number of databases. The databases act as containers of data and they are independent of each other. A MongoDB database contains one or more collections. For example, a database for a blogging application named myblogsite may typically have the collections articles, authors, comments, categories, and so on.

A collection is a set of documents. It is logically analogous to the concept of a table in a relational database. But unlike tables, you don't have to define the structure of the data that is going to be stored in the collection beforehand.

A document stored in a collection is a unit of data. A document contains a set of fields or key-value pairs. The keys are strings, the values can be of various types: strings, integers, floats, timestamps, and so on. You can even store a document as the value of a field in another document.

{
_id : ObjectId("4db31fa0ba3aba54146d851a")
username : "joegunchy"
email : "joe@mysite.org"
age : 26
is_admin : true
created : "Sun Apr 24 2011 01:52:58 GMT+0700 (BDST)"
}

Similarity with relational databases

Developers with a background on working with relational database systems will quickly recognize the similarities between the logical abstractions of the relational data model and the Mongo data model. The next figure compares components of a relational data model with those of the Mongo data model:

The next figure shows how a single row of a hypothetical table named users is mapped into a document in a collection:

Also just like columns of a RDBMS table, fields of a collection can be indexed, although implementations of indexing are different.

So much for the similarities: now let's talk briefly about the differences. The key thing that distinguishes MongoDB from a relational model is the absence of relationship constraints. There are no foreign keys in a collection and as a result there are no JOIN queries. Constraint management is typically handled in the application layer. Also, because of its flexible schema property, there is no expensive ALTER TABLE statement in MongoDB.

MongoDB supports a wide variety of platforms. It can run on Windows (XP, Vista, and 7), various flavors of Linux (Debian/Ubuntu, Fedora, CentOS, and so on), and OS X running on Intel-based Macs. In this section, we are going to see step-by-step instructions for having a MongoDB system up and running in a computer, running on Windows, Linux, or OS X.

In steps 1 to 3, we downloaded and extracted a ZIP archive that contains binary files for running MongoDB on Windows, moved and extracted it under the C:\ drive, and renamed the folder to mongodb for convenience. In step 4, we created the data directory (C:\data\db). This is the location where MongoDB will store its data files. In step 5, we execute the C:\mongodb\bin\mongod.exe program in the CMD prompt to launch the MongoDB server; this is the server that hosts multiple databases (you can also do this by double-clicking on the file in Windows Explorer). In step 6, after the server program is booted up, we invoke the C:\mongodb\bin\mongo.exe program to start the mongo interactive shell, which is a command-line interface to the MongoDB server:

C:\mongodb\bin\mongo
MongoDB shell version: 1.8.1
connection to test
type "help" for help
>

Once the shell has started, we issue the command show dbs to list all the pre-loaded databases in the server:

>show dbs
admin (empty)
local (empty)
>

The documentation at the MongoDB website recommends that you run the 64-bit version of the system. This is because the 32-bit version cannot store more than 2 gigabytes of data. If you think it is likely that the data in your database will exceed the 2 GB limit, then you should obviously download and install the 64-bit version instead. You will also need an operating system that supports running applications in the 64-bit mode. For the purpose of the practical examples shown in this book, we are just fine with the 32-bit version, you should not worry about that too much.

In step 1, we downloaded the latest stable release of MongoDB 32-bit version for Linux using the wget program, and stored it as a GZIP tarball named mongo.tgz on your machine.

In steps 2 and 3, we extracted the tarball and renamed the extracted directory to mongodb for convenience. In step 4, we created the data directory /data/db for MongoDB, and gave it permission to read from and write to that directory. In step 5, we startup the MongoDB server by executing the mongodb/bin/mongod script.

In step 6, after we have successfully launched the server, we start the mongo interactive shell:

$./mongodb/bin/mongo
MongoDB shell version: 1.8.1
url: test
connection to test
type "help" for help
>

Once the shell has started, we issue the command show dbs to list all the pre-loaded databases in the server:

>show dbs
local (empty)
admin (empty)
>

The databases listed here are special databases pre-built within the server. They are used for administration and authentication purposes. We do not need to concern ourselves with them right now.

The instructions for installing MongoDB on an OS X powered Mac machine are the same as those for Linux. You have to download the OS X specific binaries for Mongo (available at http://www.mongodb.org/downloads), and follow the same steps to execute them.

Alternatively, if you have package managers installed on your OS X (Homebrew or MacPorts), you can use them to install MongoDB.

To install MongoDB with HomeBrew use the following command:

$ brew update
$ brew install mongodb

To use MacPorts to install MongoDB use the following command:

$ sudo port install mongodb

When we launched the mongod program, it booted up with some default configuration settings, such as the path to the data directory (C:\data\db on Windows or /data/db on Unix). In real world deployments, we want to be able to specify these settings ourselves. There are two ways to achieve that. We can either modify them by supplying command-line parameters to the mongod program at invocation, or by using file-based configurations.

C:\>mongodb\bin\mongod --dbpath C:\mongodb_data

C:\>mongodb\bin\mongod -help

dbpath = D:\mongodb_data
logpath = D:\mongodb.log
logappend = true

C:\>mongodb\bin\mongod --config C:\mongodb.conf

Start MongoDB with the following settings, using a file-based configuration:

There are several ways you can shutdown a running MongoDB server.

>use admin
switched to db admin
>db.shutdownServer()

ps aef | grep mongod

In step 1, we applied the use myfirstdb command to switch to a new database namespace. Any collection/document we create now is going to be stored under this database. Next we create a collection named movies and insert some documents in it:

>db.movies.insert({name:"Source Code",genre:"sci-fi",year:2011})

The db part of the command always refers to the current database, which is "myfirstdb" in this case. The next part is the name of the collection (movies), if it does not already exist in the database, it gets created automatically when you invoke the insert() method on it. The argument to insert is a JSON object, a set of key-value pairs. After invoking the first insert, the database myfirstdb comes into physical existence. You can look into the data directory at this point, where you will find the files myfirstdb.0, myfirstdb.1, and so on that are storing the data for this database.

The find() command, invoked on the collection, returns all the documents in it:

>db.movies.find()
{ "_id" : ObjectId("4db439153ec7b6fd1c9093ec"), "name" : "Source Code", "genre" : "sci-fi", "year" : 2011 }
{ "_id" : ObjectId("4db439df3ec7b6fd1c9093ed"), "name" : "The Dark Knight", "genre" : "action", "year" : 2008 }
{ "_id" : ObjectId("4db439f33ec7b6fd1c9093ee"), "name" : "Megamind", "genre" : "animation", "year" : 2010 }
{ "_id" : ObjectId("4db439f33ec7b6fd1c9093ef"), "name" : "Paranormal Activity", "genre" : "horror", "year" : 2009 }
{ "_id" : ObjectId("4db439f43ec7b6fd1c9093f0"), "name" : "Hangover", "genre" : "comedy", "year" : 2010 }

In step 1, we download the ZIP file containing the DLL file php_mongo.dll for the PHP-MongoDB driver for PHP 5.2 (for the PHP 5.3 specific version, download http://downloads.mongodb.org/mongo-latest-php5.3vc6ts.zip instead). In step 2, we copy the php_mongo.dll file to the PHP extensions directory. If the installation directory of PHP on your machine is C:\php, the extension directory should be C:\php\ext. Then we edit the php.ini file (located under C:\php as well) to add the line extension=php_mongo.dll to it and restart Apache for the changes to take effect. Next we create and execute a one-line PHP script to invoke the phpinfo() method. If we are able to see the MongoDB driver specific information in the phpinfo() output, listed under section mongo, this means the driver was installed without a glitch.

In a Unix-based system, the PHP driver for MongoDB can be installed using the pecl (PECL - PHP Extension Community Islam) program. You need to have it installed on your machine, which can be done by using the following command:

sudo pecl install mongo

When the installation is finished, edit the php.ini file (usually found at /etc/php.ini) to add the line:

extension=mongo.so

and then restart Apache.

In case you don't have pecl installed on your machine, you can download the driver source code from GitHub, build it, and install it manually:

$ tar zxvf mongodb-mongdb-php-driver-<commit_id>.tar.gz
$ cd mongodb-mongodb-php-driver-<commit_id>
$ phpize
$ ./configure
$ sudo make install

Check out the Mongo driver installation page http://www.php.net/manual/en/mongo.installation.php on the PHP official website to get operating system specific detailed information.

Let's write a very simple PHP program that creates a connection to the MongoDB server and shows all the available databases on that server.

We just wrote a simple PHP program to test if the PHP-MongoDB driver we installed works correctly. The program does two simple things. First, it creates a connection to the Mongo server, then it lists all the databases in the server.

Let's examine the code. We created a connection from PHP to MongoDB by instantiating a Mongo object:

try{
$mongo = new Mongo();
……………………………………………………
} catch(MongoConnectionException $e) {
die($e->getMessage());
}

We instantiated the object within a try/catch block to handle the exception named MongoConnectionException in case PHP fails to connect. Once the connection was made, we invoked the listDBs() method on the Mongo object. It returned an associative array, containing three fields. The first field—databases—is an array of associative arrays, each one corresponding to a database in the server, giving us the name of the database, its size in bytes, and a flag specifying if the database is empty or not.

Array
(
[databases] => Array
(
[0] => Array
(
[name] => myfirstdb
[sizeOnDisk] => 67108864
[empty] =>
)
[1] => Array
(
[name] => adming
[sizeOnDisk] => 1
[empty] => 1
)
)
[totalSize] => 67108864
[ok] => 1
)

The totalSize field corresponds to the total size of data in the server (in bytes) and the ok flag specifies if the method ran successfully. Finally, we closed the connection by invoking the close() method on the Mongo object.

When no parameter is passed to the constructor of the Mongo class, it connects to the Mongo server running on localhost, on port 27107 (or whatever value is specified for mongo.default_host and mongo.default_port in php.ini). If we want to connect to a server running on a different host and/or port, we can pass the connection string (mongodb://<hostname>:<port_number>) as the $server parameter to the Mongo constructor. For example, to connect to a Mongo server listening on port 8888, we will type the following command:

$mongo = new Mongo($server="mongodb://localhost:8888");

We can specify for how long (in milliseconds) the driver should attempt to connect to the MongoDB server:

try {
$mongo = new Mongo($options=array('timeout'=> 100))
} catch(MongoConnectionException $e) {
die("Failed to connect to database ".$e->getMessage());
}

We supplied an array {'timeout' => 100} as the $option argument to the Mongo constructor. In case PHP fails to connect within 100 milliseconds, it will throw an exception named MongoConnectionException.

Suppose your computer is connected to a local area network. There is another computer in the network, running on the IP address 192.168.1.101. It is hosting a MongoDB server that is listening on port 8000. Write a PHP script that connects to that MongoDB server, in under one second, and lists all the databases hosted there.