What do you get with Print?

Instant access to your digital copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Redeem a companion digital copy on all Print orders

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

PHP and MongoDB Web Development Beginner's Guide

Chapter 1. Getting Started with MongoDB

We are about to begin our journey in PHP and MongoDB web development. Since you picked up this book, I assume you have some background building web apps using PHP, and you are interested in learning to develop PHP applications with MongoDB as data backend. In case you have never heard of MongoDB before, it is an open source, document-oriented database that supports the concept of flexible schema. In this chapter, we will learn what MongoDB is, and what do we gain from using MongoDB instead of trusted old SQL databases. We will start by learning briefly about the NoSQL databases (a set of database technologies that are considered alternative to RDBM systems), the basics of MongoDB, and what distinguishes it from relational databases. Then we will move on to installing and running MongoDB and hooking it up with PHP.

To sum it up, in this chapter we will:

Learn about the NoSQL movement
Learn the basic concepts behind MongoDB
Learn how to download, install, and run MongoDB on a computer
Learn to use the mongo Interactive Shell
Learn how to make PHP and MongoDB talk to each other

So let's get on with it...

The NoSQL movement

You probably have heard about NoSQL before. You may have seen it in the RSS feed headlines of your favorite tech blogs, or you overheard a conversation between developers in your favorite restaurant during lunch. NoSQL (elaborated "Not only SQL"), is a data storage technology. It is a term used to collectively identify a number of database systems, which are fundamentally different from relational databases. NoSQL databases are increasingly being used in web 2.0 applications, social networking sites where the data is mostly user generated. Because of their diverse nature, it is difficult to map user-generated content to a relational data model, the schema has to be kept as flexible as possible to reflect the changes in the content. As the popularity of such a website grows, so does the amount of data and the read-write operations on the data. With a relational database system, dealing with these problems is very hard. The developers of the application and administrators of the database have to deal with the added complexity of scaling the database operations, while keeping its performance optimum. This is why popular websites—Facebook, Twitter to name a few—have adopted NoSQL databases to store part or all of their data. These database systems have been developed (in many cases built from scratch by developers of the web applications in question!) with the goal of addressing such problems, and therefore are more suitable for such use cases. They are open source, freely available on the Internet, and their use is increasingly gaining momentum in consumer and enterprise applications.

Types of NoSQL databases

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

Key-value data stores: Data is stored as key-value pairs. Values are retrieved by keys. Redis, Dynomite, and Voldemort are examples of such databases.
Column-based databases: These databases organize the data in tables, similar to an RDBMS, however, they store the content by columns instead of rows. They are good for data warehousing applications. Examples of column-based databases are Hbase, Cassandra, Hypertable, and so on.
Document-based databases: Data is stored and organized as a collection of documents. The documents are flexible; each document can have any number of fields. Apache CouchDB and MongoDB are prominent document databases.
Graph-based data-stores: These databases apply the computer science graph theory for storing and retrieving data. They focus on interconnectivity of different parts of data. Units of data are visualized as nodes and relationships among them are defined by edges connecting the nodes. Neo4j is an example of such a database.

The NoSQL movement

Types of NoSQL databases

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

Key-value data stores: Data is stored as key-value pairs. Values are retrieved by keys. Redis, Dynomite, and Voldemort are examples of such databases.
Column-based databases: These databases organize the data in tables, similar to an RDBMS, however, they store the content by columns instead of rows. They are good for data warehousing applications. Examples of column-based databases are Hbase, Cassandra, Hypertable, and so on.
Document-based databases: Data is stored and organized as a collection of documents. The documents are flexible; each document can have any number of fields. Apache CouchDB and MongoDB are prominent document databases.
Graph-based data-stores: These databases apply the computer science graph theory for storing and retrieving data. They focus on interconnectivity of different parts of data. Units of data are visualized as nodes and relationships among them are defined by edges connecting the nodes. Neo4j is an example of such a database.

MongoDB A document-based NoSQL database

MongoDB falls into the group of document-oriented NoSQL databases. It is developed and maintained by 10gen (http://www.10gen.com). It is an open source database, written in the programming language C. The source code is licensed under AGPL and freely available at GitHub, anyone can download it from the repo https://github.com/mongodb/mongo and customize it to suit his/her needs. It is increasingly being used as a data storage layer in different kinds of applications, both web-based and nonweb-based.

Why MongoDB?

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

Easy to learn, at least easier than learning other NoSQL systems, if I dare say. Column-oriented or graph-based databases introduce radical ideas that many developers struggle to grasp. However, there is a lot of similarity in the basic concepts of MongoDB and a relational database. Developers coming from an RDBMS background, find little trouble adapting to MongoDB.
It implements the idea of flexible schema. You don't have to define the structure of the data before you start storing it, which makes it very suitable for storing non-structured data.
It is highly scalable. It comes with great features to help keep performance optimum, while the size and traffic of data grows, with little or no change in the application layer.

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.

Who is using MongoDB?

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

Craigslist: Craigslist is the world's most popular website for featuring free classified advertisements. It uses MongoDB to archive billions of records. They had been using a MySQL based solution for achieving that. Replacing them with MongoDB has allowed them to add schema changes without delay, and scale much more easily.
Foursquare: Foursquare is a popular location-based social networking application. It stores the geographical location of interesting venues (restaurants, cafes, and so on) and records when users visit these venues. It uses MongoDB for storing venue and user information.
CERN: The renowned particle physics laboratory based in Geneva, uses MongoDB as an aggregation cache for its Large Hadron Collider experiment. The results for expensive aggregation queries, performed on massive amounts of data, are stored in MongoDB for future use.

MongoDB concepts—Databases, collections, and documents

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.

Anatomy of document

Let's take a closer look at a MongoDB document. The following is an example of a document that stores certain information about a user in a web application:

{
_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)"
}

The previous document has six fields. If you have some JavaScript experience, you would recognize the structure as JSON or JavaScript Object Notation. The value for the first field, _id, is autogenerated. MongoDB automatically generates an ObjectId for each document you create in a collection and assigns it as _id for that document. This is also unique; that means no two documents in the same collection will have the same values for ID, just like a primary key of a table in a relational database. The next two fields, username and email are strings, age is an integer, and is_admin is boolean. Finally, created is a JavaScript DateTime object, represented as a string.

BSON—The data exchange format for MongoDB

We have already seen that the structure of a document imitates a JSON object. When you store this document in the database, it is serialized into a special binary encoded format, known as BSON, short for binary JSON. BSON is the default data exchange format for MongoDB. The key advantage of BSON is that it is more efficient than conventional formats such as XML and JSON, both in terms of memory consumption and processing time. Also, BSON supports all the data types supported by JSON (string, integer, double, Boolean, array, object, null) plus some special data types such as regular expression, object ID, date, binary data, and code. Programming languages such as PHP, Python, Java, and so on have libraries that manage conversion of language-specific data structures (for example, the associative array in PHP) to and from BSON. This enables the languages to easily communicate with MongoDB and manipulate the data in it.

Note

If you are interested to learn more about BSON format, you may try visiting http://bsonspec.org/.

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.

Time for action - downloading and running MongoDB on Linux

Now, we are going to learn how to download and run the MongoDB server on a Linux box:

Fire up the terminal program. Type in the following command and hit Enter

wget http://fastdl.mongodb.org/linux/mongodb-linux-i686-1.8.3.tgz > mongo.tgz

Extract the downloaded archive by using the following command:
```
tar xzf mongo.tgz
```
Rename the extracted directory by using the following command:
```
mv mongodb-linux-i686-1.8.3 mongodb
```
Create the data directory /data/db by using the following command:
```
sudo mkdir -p /data/db
sudo chown `id -u` /data/db
```
Startup the server by running the following command:
```
./mongodb/bin/mongod
```
Open another tab in the terminal and run the next command:
```
./mongodb/bin/mongo
```
Type show dbs into the shell and hit Enter.

What just happened?

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.

Note

At the time of this writing, the latest production release for MongoDB is 1.8.3. So when you try this, if a newer production release is available, you should download that version instead.

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.

Tip

Installing MongoDB using package managers

You can use the package manager of your Linux distribution (apt for Debian/Ubuntu, yum for Fedora/CentOS) to install MongoDB. To get distro-specific instructions, Ubuntu/Debian users should visit http://www.mongodb.org/display/DOCS/Ubuntu+and+Debian+packages. Users of CentOS and Fedora should visit http://www.mongodb.org/display/DOCS/CentOS+and+Fedora+Packages. The advantage of using a package manager, other than being able to install with fewer commands, is that you can launch the Mongo server and the client just by typing mongod and mongo respectively in the shell.

Installing MongoDB on OS X

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

Configuring 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.

Command-line parameters

We can override the default MongoDB settings by passing command-line parameters to the mongod program. For example, the next command tells MongoDB to use C:\mongodb_data as data directory by sending it as a --dbpath argument:

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

The following table lists some useful command-line parameters and their functions:

Parameter	What it does
`--dbpath`	Path to the directory for storing data files.
`--bind_ip`	IP address that the `mongod` server will listen on, default is `127.0.0.1`.
`--port`	Port address that `mongod` will listen on, default is `27017`.
`--logpath`	Full file path to the log file where the MongoDB messages will be written. By default all messages are written to standard output.
`--logappend`	Setting this option to true appends the messages at the end of the log file. Setting it to `false` overwrites the log.

We can see the full list of command-line options by running mongod with the--help option:

C:\>mongodb\bin\mongod --help

File-based configuration

An alternative to sending all those command-line parameters to mongod manually is to put the required configuration settings in a file and then pass the path of the file as a--config option. For example, consider the following sample configuration file:

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

We store this file to a location, say C:\mongodb.conf. Now, to start MongoDB with the these settings, we have to enter the next command in the CMD prompt:

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

mongod will be loaded with these configuration settings. Note that file-based parameters are the same as those for command-line options.

Note

If you are on a Linux machine, and you have installed Mongo using a package manager, such a configuration file may already exist in your system, typically at the location /etc/mongo.conf. You can modify that file to boot Mongo server with the configuration of your choice.

Have a go hero configure MongoDB to run with non-default settings

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

Default data directory at /usr/bin/mongo.
Default port address at 8888.
Messages will be logged at /var/logs/mongodb.log. The log file should be overwritten over time.

Stopping MongoDB

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

Hitting Control + C

In the terminal window (or CMD prompt window in case you are on Windows) running the mongod process, hit Ctrl + C. This will signal the server to do a clean shutdown, flush, and close its data files.

From the mongo shell

From the mongo interactive shell, you can issue a shutdownServer() command, causing mongod to terminate:

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

Sending INT or TERM signal in UNIX

In Linux/OS X, you can send a kill -2 <PID> signal to the process running mongod, which will cause the server to shutdown cleanly. You can get the PID by running the following command:

ps -aef | grep mongod

Time for action - creating databases, collections, and documents

The next example will demonstrate how to create a database, and insert a document in a collection using the mongo shell program:

In the mongo shell, enter the following command:
```
>use myfirstdb
```

When the prompt returns, enter the following commands to create documents in a collection named movies:

>db.movies.insert({name:"Source Code", genre:"sci-fi", year:2011})
>db.movies.insert({name:"The Dark Knight", genre:"action", year:2008})
>db.movies.insert({name:"Megamind", genre:"animation", year:2010})
>db.movies.insert({name:"Paranormal Activity", genre:"horror", year:2009})
>db.movies.insert({name:"Hangover", genre:"comedy", year:2010})

The following command returns all documents from the movies collection:
```
>db.movies.find()
```

What just happened?

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 }

Pop Quiz - configuring MongoDB

What is the default port address of MongoDB?
a. 27107
b. 27017
c. 27170
How does a new database get created in MongoDB?
a. By the command create database <databasename>
b. By the command use <databasename>
c. By doing use <databasename> first and then doing db.<collectionname>.insert(<jsondocument>)

Time for action - installing PHP driver for MongoDB on Windows

Let's try installing the driver on a Windows machine running PHP 5.2 on Apache:

Download the ZIP archive http://downloads.mongodb.org/mongo-latest-php5.2vc6ts.zip on your machine and extract it.
Copy the php_mongo.dll file from the extracted folder to the PHP extension directory; this is usually the folder name ext inside your PHP installation.
Open the php.ini file inside your PHP installation and add the following line:
```
extension=php_mongo.dll
```
Save the file and close it. Restart the Apache web server.
Open up your text editor and add the following code to a new file:
```
<?php
phpinfo();
```
Save the file as phpinfo.php inside the DocumentRoot of the Apache web server (the htdocs folder).
Execute the phpinfo.php script in your browser (http://localhost/phpinfo.php). Scroll down to find the section mongo to see all the MongoDB driver-specific information.

Congratulations! You have successfully installed the PHP driver for MongoDB.

What just happened?

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.

Note

If you are running PHP on IIS, you should download the thread-safe VC9 version of the driver instead. Get it from the URL http://downloads.mongodb.org/mongo-latest-php5.3vc9ts.zip.

Installing the PHP-MongoDB driver on Unix

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.

Time for action - creating a connection to the MongoDB server from PHP

Open up your text editor and add the following code in a new file:

<?php
try{
$mongo = new Mongo(); //create a connection to MongoDB
$databases = $mongo->listDBs(); //List all databases
echo '<pre>';
print_r($databases);
$mongo->close();
} catch(MongoConnectionException $e) {
//handle connection error
die($e->getMessage());
}

Save the file as test_connection.php under the DocumentRoot of your web server.
Open up your browser, and execute the script by going to the location http://localhost/test_connection.php:

What just happened?

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.

Configuring the PHP-MongoDB connection

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");

Specifying timeout for the connection attempt

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.

Have a go hero connect to a MongoDB server on a networked computer

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.

Key benefits

Learn to build PHP-powered dynamic web applications using MongoDB as the data backend

Handle user sessions, store real-time site analytics, build location-aware web apps, and much more, all using MongoDB and PHP

Full of step-by-step instructions and practical examples, along with challenges to test and improve your knowledge

Description

With the rise of Web 2.0, the need for a highly scalable database, capable of storing diverse user-generated content is increasing. MongoDB, an open-source, non-relational database has stepped up to meet this demand and is being used in some of the most popular websites in the world. MongoDB is one of the NoSQL databases which is gaining popularity for developing PHP Web 2.0 applications.PHP and MongoDB Web Development Beginner‚Äôs Guide is a fast-paced, hands-on guide to get started with web application development using PHP and MongoDB. The book follows a ‚ÄúCode first, explain later‚Äù approach, using practical examples in PHP to demonstrate unique features of MongoDB. It does not overwhelm you with information (or starve you of it), but gives you enough to get a solid practical grasp on the concepts.The book starts by introducing the underlying concepts of MongoDB. Each chapter contains practical examples in PHP that teache specific features of the database.The book teaches you to build a blogging application, handle user sessions and authentication, and perform aggregation with MapReduce. You will learn unique MongoDB features and solve interesting problems like real-time analytics, location-aware web apps etc. You will be guided to use MongoDB alongside MySQL to build a diverse data back-end. With its concise coverage of concepts and numerous practical examples, PHP and MongoDB Web Development Beginner‚Äôs Guide is the right choice for the PHP developer to get started with learning MongoDB.

Who is this book for?

This book assumes that you are experienced in web application development using PHP, HTML, and CSS. Having working knowledge of using a relational database system such as MySQL will help you grasp some of the concepts quicker, but it is not strictly mandatory. No prior knowledge of MongoDB is required.

What you will learn

Get MongoDB up and running on the machine (Windows/Mac/Linux)

Build a PHP-powered website with MongoDB as the data storage

Handle HTTP sessions with MongoDB

Store website analytics data in real time

Process large datasets with MapReduce

Use MongoDB to supplement your existing relational database‚Äì build data archives, cache tiers, store results of expensive SQL queries in MongoDB

Build location-aware web applications

Optimize MongoDB for better performance and security

What do you get with Print?

Instant access to your digital copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Redeem a companion digital copy on all Print orders

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

Frequently bought together

$26.99

PHP and MongoDB Web Development Beginner's Guide

$48.99

Total $ 75.98

Filter reviews by

All

Amazon verified reviews

Edgar martinez Dec 12, 2011

awesome book. I recommend it to anyone coding in php who wants to use mongo and get started right away I was playing with php and mongo in chapter 1. Great book. I loved getting started very quickly. Mongo is very easy and you can rapidly see where the benefits would be 5 star book for sure.

Amazon Verified review

cedub Feb 17, 2012

I enjoyed reading and building along with the book "PHP and MongoDB Web Development". The book is logically organized and contains many helpful hints and tutorials. I felt the content appropriately addressed the target audience, individuals with some background in web development looking to increase their exposure to a new technology. For me, the best part of the book is the useful examples and exercises, specifically using MongoDB to implement a session manager for clustered web applications, geospacial indexing, and web analytics with asynchronous writes. I found the exercises given in the book to be very relevant to the strengths of MongoDB. Furthermore, the book gives a good introduction to the Map/Reduce concept and provides good examples for those who may not be familiar with it. I thought the author did a nice job of illustrating the fact that while MongoDB has many benefits, it's not the perfect fit for every need. There are even times when it can and should be used with a relational database system and the author gives examples of when this would be an effective use and when it would not. The book provides good resources for those readers wanting to delve a bit deeper into more advanced uses and aspects of MongoDB. Overall, I found "PHP and MongoDB Web Development" to be an excellent reference for building applications with MongoDB. I would, and will, recommend this book to all of my developer colleagues.

Fran Jan 18, 2013

I learned fast and without problems. Of course Im going to need to read something more, bit the balance between time, effort, money and acknowledge is very positive.

Joe Feb 29, 2012

I found this book to be very informative for someone who is interested in MongoDB and wants to learn the type of database architecture MongoDB supports. This book has a web-centric view where it shows step-by-step examples that anyone can follow. Every chapter has a review of what is covered in the chapter, and plenty of examples to illustrate the author's points.My take on this subject is from the Database Administrator point of view, and here I found the book to be a little light on substance, but this book is clearly not marketed to that segment but to developers. Some of the advanced topics covered in this book are MapReduce, GridFS and Geospatial location and on these topics this book excels.This book would be a fine addition to any bookshelf and will have a special place in mine. It clearly shows the power of MongoDB and PHP in a Web 2.0 environment and would be a great reference to anyone in Web development.

Alessandro Pellizzari Jan 08, 2012

Disclaimer: I received the book from Packt Publishing to review it.I tried hard to be objective.General reviewIn a word: excellent. But it can be improved.If I recall correctly, this is the first book about integrating PHP and MongoDB.The writing style is easy and most concepts are clearly explained. Some dark spots remain in the functional programming concepts in the map-reduce dedicated chapter.A deeper explanation could have helped.Every chapter sports various code examples and quizzes scattered through the books help recalling just-read concepts. Maybe they are a little too few.Solutions to the quizzes are in the appendix.Every chapter also has "call to actions" (without solutions, naturally) inviting the users to implement solutions based on explained concepts.My preferred part of the books are the examples: the code is presented full and complete, and only after that, you can read the explanation, with snippets taken from it. You can have a full view of the code and analyse it by yourself, or read the description snippet by snippet.Most other technical manuals split the code, or fill it with comments, making it nearly unreadable.The book style appears to shift a little away from classical technical manual, reminding academic books.Sometimes it seems (often rightly) there is much more behind some functionalities and that the book teaches only the basic usage.In some cases it is clearly written (including a link) that you can deepen your understanding reading online articles.Some minor typos, like array fields defined by : (as in javascript) instead of => in PHP code, or missing quotes in array indexes, are easily spotted and don't lower the quality.Chapter 1: installationAfter a brief introduction to the NoSQL movement explaining its fundamentals,installation on Windows and Linux is described. As for OSX, it simply says "it is just like on Linux".Installation is so easy that it takes at most a couple of pages.Next comes server startup, covering base configuration options, and basic database and collections creation. It ends with PHP driver installation (using PEAR) and a little example script.Chapter 2: first applicationIt became the "hello world" of books covering web techs: you begin building a simple blog, covering insert, delete and alter operations. Then pagination and comments are introduced.It serves its purpouse in introducing CRUD (Create, Read, Update, Delete) operations in MongoDB, covering MongoDB query language, including limit, skip, cursors and safe writing concepts.The chapter ends with some peculiar operations (upserts, field increment, field removal) and the distinction between embedded and referenced document, also explaining how to do a "select" operation on embedded documents.Chapter 3: a session managerAfter a brief introduction, the book delves into creating a custom session handler.A (singleton) class is introduced to manage the connection to the DB, and it will be used throughout the entire book. A class is defined to handle the PHP session using a MongoDB collection. This can easily be reused in own projects, being nearly completely transparent.The chapter ends with a user login/logout example.It is useful to understand how to abstract access to MongoDB through a class, how to use upsert and also to know how to use a generic (even SQL) database to handle sessions.Chapters 4 and 5: aggregation and statisticsI cover the two chapters together because they deal with the same topics: map-reduce and group().Map-reduce is maybe the hardest topic for thos used to procedural or OOP languages, as it embraces function programming concepts. On the other hand, group() is similar to the SQL GROUP BY concept.These chapters' arguments are not easy to grasp, and I would have liked more examples. Luckily the given examples are very practical (tag cloud, web access statistics, ...) and not abstract aggregations.Capped collections are introduced here.Chapter 6: RDBMS integrationThis is maybe the least useful chapter, in my opinion, but it could be important to others. Several examples of how to connect to a SQL (MySQL) DB and MongoDB in parallel: how to use MongoDB as a query cache, or to archive old data, so to remove burden from MySQL queries.Chapter 7: GridFSThis chapter is a little thin, given the topic, but it gives you everything you need to start working with GridFS to store (binary) files in the database.MongoDB excels in its simplicity, and the examples are short and clear.One of the "call to actions" asks to implement a thumbnail gallery, saving the thumbnail along with the original image, but does not explain if you can save different files in the same document (hint: you can't).Chapter 8: geolocationThis chapter introduces MongoDB's geolocation features: 2D indexes and server-predefined procedures to search distance-based data.A good introduction, even if it leaves some itches to scratch about measure units (degrees? radians? meters?).Excellent explanation on how to use the data with Google Maps to visualize the results.Chapter 9: securityThe chapter with fewer PHP code lines in it, focuses on console administration for user (and password) access management.It also covers indexes creation and analysis: this part should have been introduced earlier in the book.Chapter 10: RockMongo and phpMoAdminA quick introduction to two web-based (PHP) interfaces for administration query and, above all, backup and restore of databases and collections.Covers pros and cons of both solutions, as well as installation and basic use.

PHP and MongoDB Web Development Beginner's Guide: Combine the power of PHP and MongoDB to build dynamic web 2.0 applications

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Types of NoSQL databases

Anatomy of document

BSON—The data exchange format for MongoDB

Similarity with relational databases

Command-line parameters

File-based configuration

Hitting Control + C

From the mongo shell

Sending INT or TERM signal in UNIX

Key benefits

Description

Who is this book for?

What you will learn

Product Details

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

Filter reviews by

People who bought this also bought

FAQs

Create a Free Account To Continue Reading

Sign in to activate your 7-day free access