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>

Installing Apache for Windows is a simple task, due in great part to the installation wizard distributed by the Apache Group. While running any web server on a Windows operating system is not as fast, stable, or secure as running a web server on a Linux/Unix machine. However, installing and configuring a development web server on a Windows-based operating system is perfectly acceptable, and is how most users get their start.

To download the Apache distribution for Windows, start at the Apache Server website, http://httpd.apache.org/, and follow the Download link. As of this writing, the current version is 2.0.49, so the file used as an example throughout this section is apache_2.0.49- win32-x86-no_ssl.msi. Once you have downloaded the installation file to your hard drive, double-click the file called apache_2.0.49-win32-x86-no_ssl.msi to start the installation wizard.

Note: When you are ask how to run Apache, choose the Run as Service for All Users radio button.

To run a basic test before moving forward to configuring your server, choose Program Files, Apache HTTP Server 2.0.49, Configure Apache Server, Test Configuration from the Windows Start menu. This will launch a console window showing a successful installation.

Configuring Apache on Windows
The master configuration file for Apache is called httpd.conf, and it lives in the conf directory, within the Apache installation directory. So if your installation directory is C:\Program Files\Apache Group\Apache2\, the httpd.conf file will be in C:\Program Files\Apache Group\Apache2\conf\.

Two values you usually want to change are the listen on port and the document root.

#Listen 12.34.56.78:80
Listen 8080
ServerName localhost:8080

By default Apache is installed to listen of default HTTP port 80. However, your Windows might has IIS (Internet Information Server) installed and takes that port already. The alternative port other developers love to use is 8080, like what I configured for my Apache.

DocumentRoot "D:/projects/www"

By default, the document root where we will serve data for web client is Path_to_apache/htdocs. You may want to change it to an easier to access location on your development environment. Remember that Apache protect your hard drive data from web user, thus you have to change the permission for users to access your new DocumentRoot.

</directory><directory "D:/projects/www">
#
# Possible values for the Options directive are "None", "All",
# or any combination of:
#   Indexes Includes FollowSymLinks SymLinksifOwnerMatch ExecCGI MultiViews
#
# Note that "MultiViews" must be named *explicitly* --- "Options All"
# doesn't give it to you.
#
# The Options directive is both complicated and important.  Please see
# http://httpd.apache.org/docs/2.2/mod/core.html#options
# for more information.
#
Options Indexes FollowSymLinks Includes ExecCGI

#
# AllowOverride controls what directives may be placed in .htaccess files.
# It can be "All", "None", or any combination of the keywords:
#   Options FileInfo AuthConfig Limit
#
AllowOverride All

#
# Controls who can get stuff from this server.
#
Order allow,deny
Allow from all

</directory>

Restart your apache so that your new configuration can take effect. Now, you can test connect to Apache web server from web browser.

http://localhost OR
http://localhost:8080 if you modify port that Apache listen.

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

So, what you are going to learn are:

• Basic of PHP
• Function, Array and basic programming classes (String, Date, Math, etc.)
• More details about string and patterns
• Web programming basis (HTML, CSS, Form, Session, JavaScript, etc.)
• Object Oriented Programming (OOP)
• Working with MySQL
• Designing OOP web application
• A Simple MVC framework
• XML & Web Service
• Secure your web application
• File and network resources
• Compare PHP4 and PHP5
• Overview of PHP web development engineering
  • PHP Frameworks (Zend, Symfony, Prado, CakePHP, CodeIgniter)
  • Advanced JavaScript
  • Introduce an online Project Management tool
  • Code generation
  • A coding convention reference

(*) Items with links show lessons are available.
(**) Item with ($)  shows some advanced articles required subscription

• PHP eclipse: Based on Eclipse open source IDE, PHP eclipse is the best FREE IDE for coding with its own PHP parser, Apache webserver and debuger. Eclipse can also work with share projects using CVS source control. Speed can be problem as it runs on Java Runtime engine and you must care about new update.
• Zend Studio Neon Beta: Zend Studio release versions are commercial but the beta is free without some cool tools displayed each time you start.
• NuSphere  phpEd:  It will be my mistake if not mention this dreaming php coder IDE. Just one thing I don’t like about it is … the cost of ownership.
• SqlYog community version: SqlYog is the best choice for Windows users to manage MySQL database. Addressing almost every need of developers, this tool is much more better than MySQL administrator and MySQL Query created by MySQL.
• Navicat: Another MySQL GUI tool, support both Windows and Linux but it’s just best choice for Linux users as SQLYog has not support Linux yet.
• DBDesigner: FabForce DbDesigner is totally free database schema designer tool. DbDesigner can connect to a selected database on MySQL to reverse tables into design element and synchronize between your design and database.
• XAMPP: A very stable server suite including Apache 2.x, PHP5, MySQL 5 and FileZilla. XAMPP is available in both Windows and Linux
• XCHM: Most of manual are in CHM version and developers always need to refer to the manual while programming. Windows users do not have problem with .chm files but Linux users need a third party tool. Though there are many .chm reader for Linux, I found XCHM the most easy to use and install.
• FireFox web developer toolbar: an extremely helpful toolbar for FireFox, support you to view HTML code, show CSS and debug JavaScript.
• W3C validators: to ensure that generated HTML and CSS are following W3C standards, W3C help developers with their online tool to validate code and inspect errors.
• TortoiseSVN: SVN client for Windows. This tool helps developers using PHP Eclipse work with SVN servers as PHP Eclipse does not support SVN very well.