Use PHP PDO for Data Object

Many PHP programmers learned how to access databases by using either the mysql or mysqli extensions. Since PHP 5.1, there’s been a better way. PHP Data Objects (PDO) provide methods for prepared statements and working with objects that will make you far more productive!

PDO Introduction

It doesn’t account for database-specific syntax, but can allow for the process of switching databases and platforms to be fairly painless, simply by switching the connection string in many instances.

This tutorial isn’t meant to be a complete how-to on SQL. It’s written primarily for people currently using the mysql or mysqli extension to help them make the jump to the more portable and powerful PDO.

[ad name=”ad-1″]

Database Support

The extension can support any database that a PDO driver has been written for. At the time of this writing, the following database drivers are available:

  1. PDO_DBLIB ( FreeTDS / Microsoft SQL Server / Sybase )
  2. PDO_FIREBIRD ( Firebird/Interbase 6 )
  3. PDO_IBM ( IBM DB2 )
  4. PDO_INFORMIX ( IBM Informix Dynamic Server )
  5. PDO_MYSQL ( MySQL 3.x/4.x/5.x )
  6. PDO_OCI ( Oracle Call Interface )
  7. PDO_ODBC ( ODBC v3 (IBM DB2, unixODBC and win32 ODBC) )
  8. PDO_PGSQL ( PostgreSQL )
  9. PDO_SQLITE ( SQLite 3 and SQLite 2 )
  10. PDO_4D ( 4D )

All of these drivers are not necessarily available on your system; here’s a quick way to find out which drivers you have:


Different databases may have slightly different connection methods. Below, the method to connect to some of the most popular databases are shown. You’ll notice that the first three are identical, other then the database type – and then SQLite has its own syntax.

try {
# MS SQL Server and Sybase with PDO_DBLIB
$DBH = new PDO("mssql:host=$host;dbname=$dbname, $user, $pass");
$DBH = new PDO("sybase:host=$host;dbname=$dbname, $user, $pass");

$DBH = new PDO("mysql:host=$host;dbname=$dbname", $user, $pass);

# SQLite Database
$DBH = new PDO("sqlite:my/database/path/database.db");
catch(PDOException $e) {
echo $e->getMessage();
Please take note of the try/catch block – you should always wrap your PDO operations in a try/catch, and use the exception mechanism – more on this shortly. Typically you’re only going to make a single connection – there are several listed to show you the syntax. $DBH stands for ‘database handle’ and will be used throughout this tutorial.

You can close any connection by setting the handle to null.

# close the connection
$DBH = null;

You can get more information on database specific options and/or connection strings for other databases from

Exceptions and PDO

PDO can use exceptions to handle errors, which means anything you do with PDO should be wrapped in a try/catch block. You can force PDO into one of three error modes by setting the error mode attribute on your newly created database handle. Here’s the syntax:


No matter what error mode you set, an error connecting will always produce an exception, and creating a connection should always be contained in a try/catch block.


This is the default error mode. If you leave it in this mode, you’ll have to check for errors in the way you’re probably used to if you used the mysql or mysqli extensions. The other two methods are more ideal for DRY programming.


This mode will issue a standard PHP warning, and allow the program to continue execution. It’s useful for debugging.


This is the mode you should want in most situations. It fires an exception, allowing you to handle errors gracefully and hide data that might help someone exploit your system. Here’s an example of taking advantage of exceptions:
# connect to the database
try {
$DBH = new PDO("mysql:host=$host;dbname=$dbname", $user, $pass);

# UH-OH! Typed DELECT instead of SELECT!
$DBH->prepare(‘DELECT name FROM people’);
catch(PDOException $e) {
echo "I’m sorry, Dave. I’m afraid I can’t do that.";
file_put_contents(‘PDOErrors.txt’, $e->getMessage(), FILE_APPEND);
There’s an intentional error in the select statement; this will cause an exception. The exception sends the details of the error to a log file, and displays a friendly (or not so friendly) message to the user.

Insert and Update

Inserting new data, or updating existing data is one of the more common database operations. Using PDO, this is normally a two-step process. Everything covered in this section applies equally to both UPDATE and INSERT operations.

Here’s an example of the most basic type of insert:

# STH means "Statement Handle"
$STH = $DBH->prepare("INSERT INTO folks ( first_name ) values ( ‘Cathy’ )");
You could also accomplish the same operation by using the exec() method, with one less call. In most situations, you’re going to use the longer method so you can take advantage of prepared statements. Even if you’re only going to use it once, using prepared statements will help protect you from SQL injection attacks.

Prepared Statements

Using prepared statements will help protect you from SQL injection.

A prepared statement is a precompiled SQL statement that can be executed multiple times by sending just the data to the server. It has the added advantage of automatically making the data used in the placeholders safe from SQL injection attacks.

You use a prepared statement by including placeholders in your SQL. Here’s three examples: one without placeholders, one with unnamed placeholders, and one with named placeholders.
view plaincopy to clipboardprint?

# no placeholders – ripe for SQL Injection!
$STH = $DBH->(“INSERT INTO folks (name, addr, city) values ($name, $addr, $city)”);

# unnamed placeholders
$STH = $DBH->(“INSERT INTO folks (name, addr, city) values (?, ?, ?);

# named placeholders
$STH = $DBH->(“INSERT INTO folks (name, addr, city) value (:name, :addr, :city)”);

You want to avoid the first method; it’s here for comparison. The choice of using named or unnamed placeholders will affect how you set data for those statements.
Unnamed Placeholders

# assign variables to each place holder, indexed 1-3
$STH->bindParam(1, $name);
$STH->bindParam(2, $addr);
$STH->bindParam(3, $city);

# insert one row
$name = "Daniel"
$addr = "1 Wicked Way";
$city = "Arlington Heights";

# insert another row with different values
$name = "Steve"
$addr = "5 Circle Drive";
$city = "Schaumburg";
There are two steps here. First, we assign variables to the various placeholders (lines 2-4). Then, we assign values to those placeholders and execute the statement. To send another set of data, just change the values of those variables and execute the statement again.

Does this seem a bit unwieldy for statements with a lot of parameters? It is. However, if your data is stored in an array, there’s an easy shortcut:

# the data we want to insert
$data = array(‘Cathy’, ‘9 Dark and Twisty Road’, ‘Cardiff’);

$STH = $DBH->("INSERT INTO folks (name, addr, city) values (?, ?, ?);
That’s easy!

The data in the array applies to the placeholders in order. $data[0] goes into the first placeholder, $data[1] the second, etc. However, if your array indexes are not in order, this won’t work properly, and you’ll need to re-index the array.


Leave a Reply