PDO is a very useful and widely use PEAR library for data manipulation. It can work with most kind of DBMS (DataBase Management System) such as MySQL (of course), Microsoft SQL, etc. PDO stands for PHP Data Object, a powerful and fast data access method for developers who need to work with different types of DBMS, handle stored procedures, process transactions or passing params to queries.

So let begin with a Database class using PDO. This class should be simple to use, aware about your ‘entity’ object, prevent you from being attacked by injection and the most important, bring use a methodology of writing clean, reusable and testable SQL queries.

Sounds like buzzwords but in fact, PDO does most of those things and our work is to just making a little more systematic in the way we use PDO functions. So, the first step is to declare a PDO object in our class:

class Database
{
protected $pdo;

function __construct($host, $db, $user, $password)
{
$this->pdo = new PDO("mysql:host=$host;dbname=$db", $user, $password);
}
}

The code above also shows you how to connect to an MySQL database with PDO. We as the consumer to pass basic informations to the constructor of the Database class so we can create a connection to the DB using our $pdo object.

The next key work is we want to pass parameter to our object to execute a query. This way, we can write only one query to use in different places and make sure that once the query runs properly, unexpected result can be caused only by bad parameters.

protected function parseSql($sqlElement, $params)
{
$sql = $this->pdo->prepare((string)$sqlElement);

if (!is_array($params))
$params = array($params);
try
{
for ($i = 1; $i < = count($params); $i++)
{
//Replace null param by empty string for wellform SQL query
if ($params[$i-1] == null)
$params[$i-1] = '';
$sql->bindValue($i, $params[$i-1]);
}
return $sql;
}
catch(Exception $ex)
{
echo "Error while parsing SQL query.<br />";
var_dump($sqlElement); echo "<br />";
var_dump($params); echo "<br />";
}
}

From the code above, first of all you can notice the $sqlElement. It is actually not a string of SQL query but a SimpleXML text element containing the SQL query and some other information our framework needs. We will talk about those XML files later but at this moment, we have to convert $sqlElement into string before use.

In order to pass params to a marked SQL query using PDO, you go through two steps. First, you ask PDO to prepare the query using the prepare() method and then use the prepared query to bind marked parameters with values using the bindValue() method.

The PDO library provide you two binding functions, bindParam() and bindValue(). They are similar in binding mechanism but different in processing the result query. Both bind a PHP variable to a question mark or named param in a query and you can specify name, data type and also the length of the parameter. However, the bindParam hold a referent to the PHP variable you bind and the result query is evaluated only at runtime. bindValue() result an evaluated query immeidately.

protected function execute($sqlId, $params, &$sql)
{
$sql = $this->parseSql($this->getSqlElement($sqlId), $params);
try
{
$sql->execute();
return true;
}
catch(Exception $ex)
{
echo "Error while executing $sqlId <br />$sql->errorInfo()";
}

}

protected function getSqlElement($sqlId)
{
$tmp = explode('.', $sqlId);
$sqlFile = SitePath . 'data' . DIRSEP . $tmp[0] . '.xml';

$root = simplexml_load_file($sqlFile);
foreach($root->sql as $sql)
{
if ($sql['Id'] == $tmp[1])
return $sql;
}
return null;
}

Back to our class, what we need now is where to get the SQL queries and how to execute one query after having it parsed with params. You may implement the SQL query resource in many different ways but for me, I prefer to put all SQL queries into XML files. That way, I never write SQL code in my PHP files meaning the code is very clean and easy to debug. I can also write and test my query first in a MySQL query client tool and the copy the tested code to my XML file, remove testing values with question marks so that I can pass to them the parameters I want from PHP code.

Writing SQL queries this way is a similar way of writing one-query-procedure. It is not only very reusable but also make the teamwork of many developers easy and help you deploy the system from testing environment to production environment quickly. Just forget about finding all PHP files where you have just change your SQL queries inside and copy them to another place.

Enough talk. Back to the XML and the getSqlElement function in our class. Our coding convention (which is very important in a PHP framework) is having the sqlId of two parts separated by a period (.). First part is the XML filename and the second part is the ‘id’ of the SQL element in that file. We don’t want to put all queries into just one file because many developers can work on that file at the same time. Also we don’t want the getSqlElement function to look through a long text file just to find out a short SQL query to run. For your information, PDO cannot run as fast as pure PHP data manipulation function. It as rate at the second position, with the great Database library ADOdb.

Now, once we have the query from XML file, pass parameters to it, the execution is simple by calling execute() function in PDO. After execute, the $sql variable holds result data that you can fetch is in many different way.

I don’t like processing data rows and columns as array of array so I use PDO fetch object style. It’s easier for you whenever you pull data form the DB, they are in form of a ‘Model’ object (in an MVC framework) and ready for you to call some logic function. That’s why we don’t process an array of columns just to create an object to continue our programming flow.

As you can see in the code below, except for querying data for just one column of the first returned row, we all fetch data as object or list of object. If we pass the class name of the object to the queryXXX function, it try to create an object of the desired class for us, otherwis it create a standard PHP object.

public function queryForColumn($sqlId, $params, $columnIndex, $defaultValue = null)
{
$sql = null;
$ret = $this->execute($sqlId, $params, $sql);
if ($ret === true)
return $sql->fetchColumn($columnIndex);
else
return $defaultValue;
}

public function queryForObject($sqlId, $params, $className = null, $defaultValue = null)
{
$sql = null;
$ret = $this->execute($sqlId, $params, $sql);
if ($ret === true)
{
if ($className != null)
$sql->setFetchMode(PDO::FETCH_CLASS, $className);
else
$sql->setFetchMode(PDO::FETCH_OBJ);

return $sql->fetch();
}
else
return $defaultValue;
}

public function queryForList($sqlId, $params, $className = null, $defaultValue = null)
{
$sql = null;
$ret = $this->execute($sqlId, $params, $sql);
if ($ret === true)
{
if ($className != null)
$sql->setFetchMode(PDO::FETCH_CLASS, $className);
else
$sql->setFetchMode(PDO::FETCH_OBJ);

return $sql->fetchAll();
}
else
return $defaultValue;
}

I do like fetching data into named object as PHP5 provides magic getter/setter methods that make my class become more reusable from project to project. The idea is a map to translate columns in Database into properties in PHP code. That way, I never break my PHP coding standard no matter what the DB naming standard is. Another roughly example is in some websites you use email as the useranme while in others you really have an username column in the database beside the email column. In the first cases, I just map email to the Username property so my code to handle user related logic does not change else where.

Here is how to create an EntityBase class with magic setter function.

class EntityBase
{
/**
* @desc Column map for consistent entity property
*/
protected $columnMap = array();

public function __set($column, $value)
{
$property = $this->columnMap[$column];
$setter = "set$property";
if (!method_exists($this, $setter))
$this->$property = $value;
else
$this->$setter($value);
}
}

Last thing, we don’t want to call a function like queryForXXX to execute an action query like Insert/Update/Delete data. So we just add a simpe query() funtion for this task.

public function query($sqlId, $params)
{
$sql = null;
return $this->execute($sqlId, $params, $sql);
}

Now, we have an useful Database class and to use it, just create an users.xml file of queries like what I have for my simple demo blog site:

< ?xml version="1.0" encoding="UTF-8"?>
<queries>
<sql Id="getUserById">
Select *
From users
Where Id = ?
</sql>

<sql Id="validateUser">
Select Count(Id)
From users
Where Email = ? AND Password = ?
</sql>

<sql Id="getIdByName">
Select Id
From users
Where email = ?
</sql>
</queries>

CSS cheatsheet

H1, H2, H3, H5 {color: purple;}

H1 B {color: red;}

     <H1>This is <B>red</B>.</H1>

     <P>This is <B>not</B>.</P>

.example {color: red;}

     <P class="example">This is an example in red.</P>

#i5 {color: red;}

     <P ID="i5">This is text with an ID of 'i5'.</P>

/* This is a comment. */

<DIV style="color:green; font-weight:bold"><H1>This heading</H1></DIV>

<P>This is <SPAN class="example">red text</SPAN> in a paragraph</P>

Example:

DIV { padding: 5px 10% 0 10% }

is the same as:DIV { padding-top:5px; padding-right:10%;

      padding-bottom:0; padding-left:10% }

width: 50px;

margin-left: 2em;

H2 {font-size: 75% }

color: #FF00FF;    /* note that this may be expressed as #F0F */

color: rgb(100%,0%,100%);

color: chocolate

url(picture.gif)

url(http://www.pix.org/lib1/pic278.gif)

list-style-image: url(bullet3.gif)

H1 {color: maroon ! important;}

<STYLE media="print">      /* print version styles here */

.noprint {display: none;}  /* items with this class won't print */

</STYLE><STYLE media="screen">     /* screen version styles go here */

.noshow {display:none;}    /* items with this class won't appear on screen */

</STYLE>

P {font-family: "Times New Roman", serif;}

EM {font-style: italic;}

H3 {font-variant: small-caps;}

B {font-weight: 700;}

H2 {font-size: 200%;}

H3 {font-size: 36pt;}

P {font: bold 12pt/14pt Helvetica,sans-serif;}

H6 {color: green;}

{ background-color: #CCCC00 }

BODY {background-image: url(bg41.gif);}

BODY { background-repeat: repeat-y }

BODY {background-attachment: fixed;}

BODY {background-position: top center;}

BODY {background: white url(bg41.gif) fixed center;}

P {letter-spacing: 0.5em;}

P {line-height: 18pt;}

H2 {line-height: 200%;}

U {text-decoration: underline;}

.old {text-decoration: line-through;}

H1 {text-transform: uppercase;}

P {text-align: justify;}

H4 {text-align: center;}

P {text-indent: 5em;}

H2 {text-indent: -25px;}

.super {vertical-align: super;}

P {word-spacing: 0.5em;}

UL {margin-top: 0.5in;}

IMG {margin-right: 30px;}

UL {margin-bottom: 0.5in;}

P {margin-left: 3em;}

H1 {margin: 2em;}

P {0% 5% 0% 5%;}

UL {padding-top: 0.5in;}

IMG {padding-right: 30px;}

UL {padding-bottom: 0.5in;}

P {padding-left: 3em;}

H1 {padding: 2ex;}

UL {border-top-width: 0.5in;}

IMG {border-right-width: 30px;}

UL {border-bottom-width: 0.5in;}

P {border-left-width: 3em;}

H1 {border-width: 2ex;}

H1 {border-color: silver black;}

H1 {border-style: solid; border-color: purple;}

UL {border-top: 0.5in solid black;}

IMG {border-right: 30px dotted blue;}

UL {border-bottom: 0.5in grooved green;}

P {border-left: 3em solid gray;}

H1 {border: 2px dashed tan;}

TABLE {width: 80%;}

IMG.icon {height: 50px;}

IMG {float: left;}

H1 {clear: both;}

.hide {display: none;}

TD {white-space: nowrap;}

TT {white-space: pre;}

UL {list-style-type: square;}

OL {list-style-type: lower-roman;}

UL {list-style-image: url(bullet3.gif);}

LI {list-style-position: inside;}

UL {list-style: square url(bullet3.gif) outer;}

{ left: 2% }

{ top: -20px }

{ overflow: auto }

{ position: relative }

{ visibility: hidden }

{ z-index: 2 }

p.framed { clip: rect (2em auto auto auto) }

A:link {color: #900}

A:link IMG { border: solid blue }

A:hover { background:#ffff00; }

A:visited {}

A:active {} /* style visible only at moment of click */

A.external:link { color: magenta }<A CLASS="external" href="http://out.side/">external link</A>

P:first-line {color: red;}

     <P>The first line of this paragraph is

 red. More blah blah blah...</P>

P:first-letter {color: red;}

     <P>The capital 'T' at the beginning of this paragraph is red.</P>

Example:<STYLE>

.page {page-break-after: always}

</STYLE>

...

<P CLASS="page">

...

{ cursor: help }

Zend components are not only easy to use but also designed with standards and deep thought. They are also very isolated so that coders are not required to use Zend MVC framework to use a component. Off course, there are some dependencies you have to take care of, for example, Zend_Authentication depends on Zend_Session or Zend_Feed depends on Zend_Http.Zend library is about 13Mb in its latest release at this moment, contains the whole framework suite and examples.

• To download Zend framework: http://framework.zend.com/download
• To download API and Programmer ref. guide: http://framework.zend.com/download/documentation/

Here are steps to take Zend components in to use in my own project:

1. Extract ZendFramework/library/Zend into my /includes folder. Actually, I put only components I need but if you don’t want to concern with component dependencies, put them all here.
2. Zend will make a lot of include file once you include one component into your code. So in order to forget this including process, create an __autoload() function for PHP5 to take of this inclusion.

   // For loading classes
   function __autoload($class_name) {
   $filename = $class_name . '.php';
   include_once($filename);
   }
   

3. Then you have to add /includes/Zend into your include_path as you will don’t know where does a Zend component want to include its dependency or at least, you really don’t care.

   $includePath = get_include_path();
   $includePath .= PATH_SEPARATOR . SitePath . 'includes';
   $includePath .= PATH_SEPARATOR . SitePath . 'includes' . DIRSEP . 'Zend';
   $includePath .= PATH_SEPARATOR . SitePath . 'framework';
   $includePath .= PATH_SEPARATOR . SitePath . 'data' . DIRSEP . 'entities';
   set_include_path($includePath);
   

4. Now, let’s test Zend_Feed component which requires Http, Uri, Validate, Exception and Loader

require_once 'Zend/Feed.php';

// Fetch the latest Slashdot headlines
try {
$phpvnRss = Zend_Feed::import('http://artemis.com.vn/blogvui/?feed=rss2');
} catch (Zend_Feed_Exception $e) {
// feed import failed
echo "Exception caught importing feed: {$e->getMessage()}\n";
exit;
}

// Initialize the channel data array
$channel = array(
'title' => $phpvnRss->title(),
'link' => $phpvnRss->link(),
'description' => $phpvnRss->description(),
'items' => array()
);

// Loop over each channel item and store relevant data
foreach ($phpvnRss as $item) {
$channel['items'][] = array(
'title' => $item->title(),
'link' => $item->link(),
'description' => $item->description()
);
}

if (count($channel['items']))
{
echo "<ul>";
for ($i = 0; $i < 5 && $i < count($channel['items']); $i++)
{
$item = $channel['items'][$i];
echo '<li><a href="' . $item['link'] . '" target="_blank">'.$item['title'].'</a>';
}
echo "</ul>";
}