Code Naked When the going gets tough, the tough get naked

4Sep/100

Finally, a note is added to PHP.net

So I have tried many times over the years to add a note to one of the reference pages on PHP but for some reason it never worked ... Well I tried again on Thursday and it finally worked! Check it out and let me know if you have any questions: http://www.php.net/manual/en/function.array-walk.php#99748

Filed under: Uncategorized No Comments

3Sep/100

Finally, prioritized inbox has arrived

So Google announced recently the ability to have mail in your inbox prioritized based on your usage patterns and a bunch of other junk. I have been asking for this for YEARS! I mean, if we have filtering for spam why not have filtering for email that you need to keep but isn't the most important? I personally hate email, I find it scary that there are literally thousands of middle managers employed who's sole role in a company is to filter email and forward it around to the people that need it to get their job done. I hate having to stop what I am doing every 15 minutes or so (okay more like 30 minutes if I remember) to see if there is anything important that I need to read. Now, gmail will help me out by putting those import emails right at the top so I can take care of them straight away. Sweet! You can read more about the GMail Priority Inbox here.

Filed under: Uncategorized No Comments

23May/100

Zend_Form element decoration

So recently I was asked to work with the Zend Framework on an application and I ran into a common issue that developers have when dealing with Zend_Form. That issue is the fact that basically no client side developer I have ever worked with wraps their form elements in <dl> <dt> and <dd> tags. Not saying that Zend was incorrect in using those tags for the forms, after all I have yet to see two client side developers use the same code to create a form! The current project I was working on used <p> tags to wrap them, it was a bit weird to be honest, I am used to divs with variations as the main technique used to lay out the form. Trying to solve this issue led me to embark on a fun trek through Google search results that were mostly incoherent and generally useless. Then I decided to look at the code. To keep it simple, here are a few quick and dirty examples of forms that require different element wrappings and the corresponding form class that makes it happen.

This form wraps the elements in <p> tags and has classes applied to both the container <p> and the input elements themselves. Here's the Zend_Form code that makes it happen:

<?php
	class Application_Form_Category extends Zend_Form
	{
		public function __construct($options) {
			$this->setDisableLoadDefaultDecorators(true)
				 ->addDecorator('FormElements')
				 ->addDecorator('Form');
			
			$this->setElementDecorators(
				array(
				'ViewHelper',
				'Label',
				'Errors',
				//wrap elements in  <p>'s
				new Zend_Form_Decorator_HtmlTag(array('tag' => 'p')) 
				)
			);

parent::__construct($options);
		}

public function init()
		{
			// Set the method for the display form to POST
			$this->setMethod('post');
			// New Category
			$this->addElement(
				'text',
				'new_category',
				array(
					'label'      => 'New Category',
					'class'      => 'input-text',
					'required'   => true,
					'filters'    => array('StringTrim'),
					'decorators' => array(
					'ViewHelper',
					'Label',
					'Errors',
					new Zend_Form_Decorator_HtmlTag(array('tag' => 'p', 'class' => 'one_half'))
				),
				'validators' => array(
					array(
						'validator' => 'StringLength',
						'options' => array(0, 30))
					)
				)
			);

// Submit button
			$this->addElement(
				'submit',
				'submit',
				array(
					'label' => '',
					'ignore' => true,
					'class' => 'input-submit'
				)
			);
		}
	}
	?>

Now you might have some questions about some of the things I did. Here are some bullet points to help clear things up:

Yes, the setElementDecorators method in the constructor wraps every label and input in a <p> tag.
Yes, I know that adding the ViewHelper decorator to the new_category element in init is basically doing the exact same thing. BUT it is also adding a class "one_half" to the <p> tag. This is how the developer was floating the elements for a two column layout.
The new_category input element itself also has a class applied to it of "input-test", you can ignore that part of you aren't styling them yourself.
The label of the submit element was purposely set to nothing, for some reason Zend_Form was adding the label element to the submit button if I didn't null it.

Not so bad right? Let take a look at another example that uses <li> tags around the form elements. This one is special because it also requires a <ul> tag wrap all of the form element <li> tags. Check out what that form should look like:

Nothing too fancy, I have seen forms done with li tags many times. Here's the Zend_Form code that makes the magic happen:

This one is basically the exact same as the last one with the exception that it adds the HtmlTag decorator back to the default decorators and sets its tag value to ul. It's all pretty simple really once you go digging and figure out what is going on with all of the decorators.

Tagged as: zend_form No Comments

1Apr/100

Hello wordpress!

So I decided to move my blog from the somewhat archaic feeling Serendipity to Wordpress. There are some migration tools but I'll prolly just end up recreating the blog posts by hand in the db. No biggie, it's not like I am that prolific of a blogger.

Filed under: Uncategorized No Comments

12Sep/080

Using Mappers to Persist Data

One of the things that is most annoying to deal with when developing software is converting your objects into records to be inserted into your database and then getting them back out. One of the key Patterns for doing this is known as the Data Mapper. I have followed the examples from PoEAA fairly closely when implementing this pattern, but I have diverted in places where the typing mechanisms in PHP make things easier than in Java. My mapping consists of four primary classes:

Naked_Mapper_Abstract - The Abstract parent of all Data Mappers
Naked_Mapper_DataMap - Contains the actual property to field mapping definition
Naked_Mapper_ObjectData - A helper class that accepts an object and a datamap and returns a hash of property=>value or fields=>value pairs.
Naked_Mapper_Registry - A helper class that knows how to find Mappers for domain objects and caches them for subsequent calls

In the examples below I have stripped out all of the extra junk such as logging and caching so that the basic concept can be clear. The central class that all of the other classes build on is the concept of the Data Map. Here is an example of a concrete Album mapper that builds its DataMap on construction: A data map takes the class name and the table name as constructor parameters. You add the identity property and then the rest of the property to field mappings. Pretty simple.

Filed under: PHP No Comments

12Sep/080

Debugging with FirePHP

One of the nicest features to have when you are developing an application is a decent debug console so that you can see what your application is doing without having to look through ten log files and put var_dumps that you have to comment out all through your code. In the Zend Framework v1.6 we get a new feature based on FirePHP which will allow us to log directly to the Firebug console with a simple API call from PHP. Here is an example of how this looks in my application: It's actually pretty easy to get this working, I did have to make one change to the Wildfire library though when I first started using it in order to get it behaving as I expected. I opened a bug which was resolved before 1.6 rolled out the door. In setting this up, I wanted the debugging to be as transparent as possible, one of the great things about Zend_Log is the ability to add filters to the individual writers so that the main log writer that writes things out to a file can ignore log messages with a priority of debug or info quite easily. This means that on production we can just not include the Firebug writer and we can rest assured that no sensitive information is being sent to the browser.

Okay, lets break down what I have done:

I changed the Error Controller so that it logs exceptions
I added a profiler to my Db class
I added a custom Memcached class so that I could ask it for stats
I modified my application environment so that it could know if was in production or development
I have the Workspace logging init add the Firebug logger if we are in dev
I added the Debug Front Controller plugin so that I could log stuff like action exec times etc
I installed the FirePHP extension for Firefox
I enabled console and net for my site in Firebug
I saw glorious debug info and went to get a beer to celebrate.

Although it's great for developers to have this look into your applications inner workings, in the wrong hands this kind of information can lead to your site getting seriously p0wned. In order to prevent this, I don't even add the FirePHP writer to Zend_Log if I am not in a development environment. Here's how I accomplish this in my Workspace logger init method:

Here's what my controller plugin looks like:

class Naked_Controller_Plugin_Debug extends Zend_Controller_Plugin_Abstract
{
    /**
     * @var float $dispatchStartTime
     */
    protected $dispatchStartTime;

/**
     * @var float $actionStartTime
     */
    protected $actionStartTime;

/**
     * @var array $initialMemcachedStats
     */
    protected $initialMemcachedStats;

/**
     * Record the start time for the dispatch loop startup
     *
     * @param Zend_Controller_Request_Abstract $request
     * @return null
     */
    public function dispatchLoopStartup(Zend_Controller_Request_Abstract $request)
    {
        $this->dispatchStartTime = array_sum(explode(' ', microtime()));

// Only try to get stats if caching is enabled
        if (Naked_App::getEnvironment()->isCacheEnabled()) {
            $this->initialMemcachedStats = Naked_App::getWorkspace()->getCache()->getStats();
        } else {
            Naked_App::getWorkspace()->getLogger()->debug('Memcached is disabled');
        }
    }

/**
     * record the start time for the current action
     */
    public function preDispatch(Zend_Controller_Request_Abstract $request)
    {
        $this->actionStartTime = array_sum(explode(' ', microtime()));
    }

/**
     * Log the execution time for the current action
     */
    public function postDispatch(Zend_Controller_Request_Abstract $request) {
        $execTime = array_sum(explode(' ', microtime())) - $this->actionStartTime;
        $action = $request->getModuleName() .'::'.$request->getControllerName().'::'.$request->getActionName();
        Naked_App::getWorkspace()->getLogger()->debug("{$action} action took $execTime seconds to execute");
    }

/**
     * Log the total execution time for the dispatch loop and display all other
     * debug information
     */
    public function dispatchLoopShutdown()
    {
        $this->debugSession();
        $this->debugMemcached();
        $this->debugDatabase();

$execTime = array_sum(explode(' ', microtime())) - $this->dispatchStartTime;
        Naked_App::getWorkspace()->getLogger()->debug("Script took $execTime seconds to execute");
    }

/**
     * Log the session contents
     */
    protected function debugSession()
    {
        $table = array (
            'Session',
            array(
                array('Namespace', 'Values')
            )
        );

foreach ($_SESSION as $namespace=>$values) {
            $table[1][] = array($namespace, $values);
        }

Naked_App::getWorkspace()->getLogger()->tabular($table);
    }

/**
     * Debug memcached
     */
    protected function debugMemcached()
    {
        if (! Naked_App::getEnvironment()->isCacheEnabled()) {
            Naked_App::getWorkspace()->getLogger()->debug('Memcache is DISABLED');
            return;
        }

$table = array (
            'Memcached',
            array(
                array('Property', 'Value')
            )
        );

$stats = Naked_App::getWorkspace()->getCache()->getStats();

foreach ($stats as $server => $data) {
            $table[1][] = array($server);
            $table[1][] = array('Items in cache', number_format($data['curr_items']));
            $table[1][] = array('Memory usage', number_format($data['bytes']) . ' bytes');

$getsThisRequest = $data['cmd_get'] - $this->initialMemcachedStats[$server]['cmd_get'];
            $table[1][] = array('Gets', number_format($data['cmd_get']) . '(' . $getsThisRequest . ')');

$missesThisRequest = $data['get_misses'] - $this->initialMemcachedStats[$server]['get_misses'];
            $table[1][] = array('Get misses', number_format($data['get_misses']) . '(' . $missesThisRequest . ')');

$setsThisRequest = $data['cmd_set'] - $this->initialMemcachedStats[$server]['cmd_set'];
            $table[1][] = array('Sets', number_format($data['cmd_set']) . '(' . $setsThisRequest . ')');
        }

Naked_App::getWorkspace()->getLogger()->tabular($table);
    }

/**
     * Using the Database profiler, output some helpful information concerning
     * database interaction.
     */
    protected function debugDatabase()
    {
        $logger = Naked_App::getWorkspace()->getLogger();
        $db = Naked_App::getWorkspace()->getDb();

$profiles = $db->getProfiler()->getProfiles();

foreach ($profiles as $queryId => $profile) {
            $logger->debug("Executed query $queryId : {$profile['sql']}");
            $logger->debug("Query $queryId took {$profile['elapsed']} seconds and involved {$profile['num_rows']} rows");

$explain = array(
                'Explanation of plan for query #' . $queryId,
                array(
                    array('id', 'Select Type', 'Table ', 'Type', 'Possible Keys', 'Key Used', 'Key Length', 'Ref Type', '# Rows', 'Extra')
                )
            );

// Some query types will throw exceptions when an explain is attempted
            try {
                foreach ($db->getProfiler()->getExplainPlan($queryId) as $explainRecord) {
                    $explain[1][] = array_values(get_object_vars($explainRecord));
                }

$logger->tabular($explain);
            } catch (Naked_Db_Exception $e) {
                $logger->debug("An execution plan for query # {$queryId} could not be retrieved: {$e->getMessage()}");
            }
        }
    }
}

The items that are logged are as follows:

The full paths to all view scripts that have been rendered - including layouts
The Module::controller::actions performed as well as how long it took to perform each action
An expandable table with the contents of the current user session
An expandable table of the current memcached stats. If memached has been disabled, it will indicate such. Numbers in parenthesis indicates the number of each operation that occured during the current request. This is a great way to ensure that the cache is actually working properly.
A timing of the requests entire processing time. This is basically measured as the difference between the dispatchLoopStartup and dispatchLoopShutdown events.
Any exceptions that were encountered are sent to the debug console with an expandable tree for the traceback.
The last and perhaps most import part of the debug console is the SQL query profiling. For each query that is run, the debug console dumps the query itself as well as the execution time for that SQL query. it also includes an explain plan of that query in an expandable table format so that you can see what decisions the MySQL optimizer made when it processed your query. This can be a quick way to look for "using key: none" or "temporary table" inefficiencies in your queries.

The added visibility into your application's inner workings in such a non-intrusive way are indispensable to me when developing. Once you use it in your own applications I am sure you will feel the same way.

Filed under: PHP No Comments

18Aug/081

Adding a Profiler to a Db Class

First of all, in case you don't know me that well, you need to know that I am a big fan of unit testing. Although I like the idea of using a database abstraction layer, I have come to dislike PDO for several reasons. First of all it's behavior is not the same for every database driver that you use. This is not a fault of PDO itself so much as the authors of the database specific drivers that are not able to implement the entire feature set. Secondly, I am not sure I buy into this "You can just switch databases and all you have to do is change the config" argument. Any application that either has a DBA on the team or cares at all about performance will have tailored SQL to get the most out of the database - which as you know tends to be the main bottleneck in an application. The main reason that I dislike PDO is that it is such a pain to mock it while unit testing. For some reason it was deemed necessary to have PDO connect on construct rather than either having an explicit connect() method or a lazy connect when one is needed. Even though you can specify that you don't run the constructor when you mock PDO, you then run into internal trouble as some settings are not set up properly and you get errors. At work, I tend to just wrap PDO with my own Db class that proxies calls to the internal PDO instance so that I can mock my Db class and everything plays nicely.

For my own junk, I tend to always go with MySQL as my database so I don't really like the idea of adding a wrapper to a wrapper to a wrapper in order to talk to it. I use MySQLi as my db class, but I still wrap it so that I can do lazy connects. The reason for this is so that once my cache is warmed up, and the user has logged in, I don't even connect to the database during a normal session. This helps tremendously as the connection to the database is the most expensive part of database interaction. If I do need to perform any write operations, they are performed by the Unit of Work, which doesn't kick in until the dipatchLoopShutdown. (I still have a few tweaks in regards to caching with my Unit of Work implementation before I show you how that works.) This also helps to ensure that if I do need to open a connection, it's for the shortest amount of time possible.

First, let's take a look at the MySQLi wrapper.

class Naked_Db
{
    /**
     * @var mysqli $mysqli
     */
    protected $mysqli;

/**
     * @var boolean $connected
     */
    protected $connected;

/**
     * @var boolean $inTransaction
     */
    protected $inTransaction;

/**
     * @var string $host
     */
    protected $host;

/**
     * @var string $username
     */
    protected $username;

/**
     * @var string $password
     */
    protected $password;

/**
     * @var string $db
     */
    protected $db;

/**
     * @var naked_Db_profiler $profiler
     */
    protected $profiler;

/**
     * Constructor
     */
    public function __construct($host, $username, $password, $db)
    {
        $this->host = $host;
        $this->username = $username;
        $this->password = $password;
        $this->db = $db;

// Get the MySQLi object prepared to connect
        $this->mysqli = mysqli_init();
        $this->connected = false;

$this->profiler = new Naked_Db_Profiler($this, true);
    }

/**
     * Connect to the database
     *
     * @throws Naked_Db_Exception
     */
    public function connect()
    {
        if (!$this->isConnected()) {
            // Connect for real now
            $this->connected = $this->mysqli->real_connect(
                                    $this->host,
                                    $this->username,
                                    $this->password,
                                    $this->db);

if (mysqli_connect_errno()) {
                throw new Naked_Db_Exception('Could not connect: ' . mysqli_connect_error());
            }

$backtrace = debug_backtrace();
            $message = "Naked_Db: Connected to database {$this->db} from " .
                       "{$backtrace[2]['class']}::{$backtrace[2]['function']} " .
                       "({$backtrace[1]['class']}::{$backtrace[1]['function']})";
            Naked_App::getWorkspace()->getLogger()->info($message);
        }
    }

/**
     * Close a connection to the database
     */
    public function close()
    {
        $this->mysqli->close();
        $this->connected = false;
        Naked_App::getWorkspace()->getLogger()->info("Naked_Db: Disconnected from database {$this->db}");
    }

/**
     * Determine if we are connected to the database
     *
     * @return boolean
     */
    public function isConnected()
    {
        return $this->connected > 0;
    }

/**
     * Perform a SQL query
     *
     * @param string $sql
     * @return Naked_Db_Result
     * @throws Naked_Db_Exception
     */
    public function query($sql)
    {
        $this->connect();

$queryId = $this->profiler->queryStart($sql);
        $result = $this->mysqli->query($sql);

if (true === $result) {
            $this->profiler->queryEnd($queryId, $this->mysqli->affected_rows);
            return true;
        } else if ($result instanceof mysqli_result ) {
            $this->profiler->queryEnd($queryId, $result->num_rows);
            return new Naked_Db_Result($result);
        } else {
            throw new Naked_Db_Exception($this->mysqli->error);
        }
    }

/**
     * Quote and escape the provided value
     *
     * Sucks that we need a connection to do this...
     *
     * @param mixed $value
     * @return string
     */
    public function quote($value)
    {
        $this->connect();
        $value = $this->mysqli->escape_string($value);

return "'{$value}'";
    }

/**
     * Escape the provided value
     *
     * @param mixed $value
     * @return string
     */
    public function escape($value)
    {
        $this->connect();
        return $this->mysqli->escape_string($value);
    }

/**
     * Create a prepared statement from the provided SQL
     *
     * @param string $sql
     * @return Naked_Db_Statement
     */
    public function prepare($sql)
    {
        $this->connect();

$statement = $this->mysqli->prepare($sql);

if(false === $statement) {
            throw new Naked_Db_Exception($this->mysqli->error);
        }

return new Naked_Db_Statement($statement, $sql, $this->profiler);
    }

/**
     * Begin a transaction
     */
    public function beginTransaction()
    {
        $this->connect();

// Turn off autocommit.
        $this->mysqli->autocommit(false);

// Begin the transaction
        $this->mysqli->query('BEGIN;');

$this->inTransaction = true;
    }

/**
     * Commit the active transaction
     */
    public function commit()
    {
        if (!$this->inTransaction) {
            throw new Naked_Db_Exception('Attempted to commit when no transaction started');
        }

$this->mysqli->commit();
        $this->inTransaction = false;
    }

/**
     * Roll back the active transaction
     */
    public function rollback()
    {
        if (!$this->inTransaction) {
            throw new Naked_Db_Exception('Attempted to commit when no transaction started');
        }

$this->mysqli->rollback();
        $this->inTransaction = false;
    }

/**
     * @return Naked_Db_Profiler
     */
    public function getProfiler()
    {
        return $this->profiler;
    }
}

Pretty simple really as it essentially just wraps the MySQLi class. There are a couple of things to note however. First of all, if you are wondering what Naked_App::getWorkspace() is ... I'll explain that in my next post. Basically think of it like a registry that houses all of the tools I need to get work done in an application such as a database connection, a logger, and access control list etc. Another thing to note is that I am calling $this->connect() at the start of each method that requires that I am connected to the database. This is how I implement the lazy connect functionality. To make sure that I am not connecting needlessly I also log the fact that I connected and which methods forced me to connect. This can help me track down caching issues among other things. You can see what a typical log message looks like in FirePHP here:

I also wrap two other MySQLi classes for convenience. The first is the mysqli_result object:

class Naked_Db_Result
{
    /**
     * @var Mysqli_result $result
     */
    protected $result;

/**
     * Constructor
     * 
     * @param mysqli_result $result
     */
    public function __construct($result)
    {
        $this->result = $result;
    }

/**
     * Fetch an object from the result set
     * 
     * @return stdClass
     */
    public function fetch()
    {
        return $this->result->fetch_object();
    }

/**
     * Fetch an array of objects fromt he result set
     * 
     * @return array
     */
    public function fetchAll()
    {
        $results = new ArrayObject();

while ($dataObject = $this->result->fetch_object()) {
            $results->append($dataObject);
        }

return $results;
    }

/**
     * Return the number of rows in the result set
     * 
     * @return integer
     */
    public function numRows()
    {
        return $this->result->num_rows;
    }

/**
     * Close the result set
     */
    public function close()
    {
        $this->result->close();
    }
}

I basically just use it to be able to fetch one or more data objects from the result set. I like to use objects as much as I can. The other class that I wrap is the mysqli_stmt class, which is basically a prepared statement. I have a really simple one at the moment, you can see it here:

class Naked_Db_Statement
{
    /**
     * @var mysqli_stmt $statement
     */
    protected $statement;

/**
     * @var string $sql
     */
    protected $sql;

/**
     * @var Naked_Db_Profiler $profiler
     */
    protected $profiler;

/**
     * Constructor
     *
     * @param mysqli_stmt $statement
     * @param string $sql
     * @param Naked_Db_Profiler $profiler
     * @return new naked_Db_Statement
     */
    public function __construct(mysqli_stmt $statement, $sql, $profiler=null)
    {
        $this->statement = $statement;
        $this->sql = $sql;
        $this->profiler = $profiler;
    }

/**
     * Execute the prepared statement
     *
     * @return boolean
     */
    public function execute()
    {
        $queryId = $this->profiler->queryStart($this->sql);
        $result = $this->statement->execute();
        $this->profiler->queryEnd($queryId, $this->affectedRows());
        return $result;
    }

/**
     * Return the id from last insert
     *
     * @return integer
     */
    public function lastInsertId()
    {
        return $this->statement->insert_id();
    }

/**
     * Return the number of rows affected by the last operation
     */
    public function affectedRows()
    {
        return $this->statement->affected_rows();
    }
}

As a convention I only use prepared statements for write operations so I don't need to support results from a statement execute() call. The last piece of the puzzle and the point of the entire article is the profiler. Here it is:

class Naked_Db_Profiler
{
    /**
     * @var Naked_Db $db
     */
    protected $db;

/**
     * @var array $profiles
     */
    protected $profiles = array();

/**
     * @var integer $queryIndex
     */
    protected $queryIndex = 0;

/**
     * @var boolean $enabled
     */
    protected $enabled;

/**
     * Constructor
     *
     * @param Naked_Db $db
     * @param boolean $enabled
     */
    public function __construct(Naked_Db $db, $enabled=false)
    {
        $this->db = $db;
        $this->enabled = $enabled;
    }

/**
     * Get all profiled queries
     *
     * @return array
     */
    public function getProfiles()
    {
        return $this->profiles;
    }

/**
     * Profile the start of a query
     *
     * @return integer
     */
    public function queryStart($sql)
    {
        if (!$this->enabled) {
            return false;
        }

$this->profiles[$this->queryIndex]['start'] = $this->getTime();
        $this->profiles[$this->queryIndex]['sql'] = $sql;

return $this->queryIndex++;
    }

/**
     * Profile the end of a query
     *
     * @param integer $index
     * @param integer $numRows
     * @return boolean
     */
    public function queryEnd($index=null, $numRows=0)
    {
        // If we are not enabled or the index is invalid don't do anything
        if (!$this->enabled || false === $index) {
            return false;
        }

if (is_null($index)) {
            $index = $this->queryIndex;
        }

$this->profiles[$index]['num_rows'] = $numRows;
        $this->profiles[$index]['end'] = $this->getTime();

$elapsed = $this->profiles[$index]['end'] - $this->profiles[$index]['start'];
        $this->profiles[$index]['elapsed'] = number_format($elapsed, 6);

return true;
    }

/**
     * Get the explain plan for a given query
     *
     * @param integer $index
     * @return array
     * @throws Naked_Db_Exception
     */
    public function getExplainPlan($index=null)
    {
        if (is_null($index)) {
            $index = $this->queryIndex;
        }

$sql = $this->profiles[$index]['sql'];

// We cannot get an explain plan for queries with bound parameters
        if (preg_match('#= ?:#', $sql) || strpos($sql, '?') !== false) {
            throw new Naked_Db_Exception('Query is a prepared statment with bound parameters.');
        }

// We can only explain select statements
        if (strpos($sql, 'SELECT') === false) {
            throw new Naked_Db_Exception('Query is not a select statement');
        }

// We can't explain found_rows calls either
        if (strpos($sql, 'SELECT FOUND_ROWS()') !== false) {
            throw new Naked_Db_Exception('Query is for the number of found rows');
        }

// We are using preg_replace because we want to limit the number of replacements
        $sql = preg_replace('#SELECT#', 'EXPLAIN SELECT', $this->profiles[$index]['sql'], 1);

$results = $this->db->query($sql);
        $records = $results->fetchAll();
        unset($results);

return $records;
        if (is_null($index)) {
            $index = $this->queryIndex;
        }
    }

/**
     * Get an accurate timestamp
     *
     * @return float
     */
    protected function getTime()
    {
        return (float) array_sum(explode(' ', microtime(true)));
    }
}

Basically all it does it record the start and end times of a query as well as providing a means for getting the explain plans for queries that have already run. It doesn't actually perform the explain queries until you explicitly ask for them, that way i can keep the profiler overhead lower for the default usage. Speaking of usage, here's how I display database debug information:

Now of course you know I don't just vomit this information all over my page, I log it to FirePHP. But that's a topic for another time!

Filed under: PHP 1 Comment

30Jul/080

Wrap PDO and be Happy

So I normally don't bother using PDO as most of my projects are MySQL based, for a project at work though it was decided to use it. One thing that I get really annoyed with is the fact that PDO attempts to connect on instantiation. I have no idea why you would want that to be the default behavior as it makes so many things a pain. Where it really bites you is in unit testing because it's very difficult to mock PDO.

So, instead of using PDO directly I wrap it with my own class that defers instantiating PDO until absolutely necessary. In this way, I can mock my database class quite easily so that I can test without touching the database. So let's take a look at some code...Here is the main class that wraps PDO:

class My_Db
{
    protected $dsn;
    protected $username;
    protected $password;
    protected $driverOptions;
    protected $pdo;

protected $inTransaction;

/**
     * Constructor.
     * @param string $dsn PDO DSN connection string
     * @param string $username Username
     * @param string $password Password
     * @param array $driverOptions Optional array of PDO driver-specific
     *                             options.
     */
    function __construct($dsn, $username = null, $password = null, array $driverOptions = null)
    {
        $this->pdo = false;
        $this->dsn = $dsn;
        $this->username = $username;
        $this->password = $password;
        $this->driverOptions = $driverOptions;

$this->inTransaction = false;
    }

/**
     * Determine if we have connected PDO already
     *
     * @return boolean
     */
    public function isConnected()
    {
        return $this->pdo instanceof PDO;
    }

/**
     * Instantiate a PDO object for use
     *
     * @return boolean
     */
    protected function connectPdo()
    {
        if($this->isConnected()) {
            return true;
        }

try {
            $this->pdo = new PDO($this->dsn, $this->username, $this->password, $this->driverOptions);
        } catch (PDOException $e) {
            throw new My_Db_Exception('Connection failed: ' . $e->getMessage());
        }

// Exceptions should be thrown on errors.
        $this->pdo->setAttribute(
            PDO::ATTR_ERRMODE,
            PDO::ERRMODE_EXCEPTION);

// Return column names in lowercase
        $this->pdo->setAttribute(
            PDO::ATTR_CASE,
            PDO::CASE_LOWER);
    }

/**
     * Begin a database transaction
     */
    public function beginTransaction()
    {
        $this->connectPdo();
        $this->pdo->beginTransaction();
        $this->inTransaction = true;
    }

/**
     * Commit an existing transaction
     */
    public function commit()
    {
        if(!$this->inTransaction) {
            throw new My_Db_Exception('Attempting to commit when no transaction exists');
        }

$this->pdo->commit();
        $this->inTransaction = false;
    }

/**
     * Get the error code from the last operation
     *
     * @return integer
     */
    public function errorCode()
    {
        if ($this->isConnected()) {
            return $this->pdo->errorCode();
        }
    }

/**
     * Get the error information from the last operation
     *
     * @return string
     */
    public function errorInfo()
    {
        if ($this->isConnected()) {
            return $this->pdo->errorInfo();
        }
    }

/**
     * Execute a SQL query
     *
     * @param string $statement
     */
    public function exec($statement) {
        $this->connectPdo();
        $this->pdo->exec($statement);
    }

/**
     * Get the value of a PDO attribute
     *
     * @param integer $attribute
     * @return mixed
     */
    public function getAttribute(integer $attribute)
    {
        $this->connectPdo();
        return $this->pdo->getAttribute($attribute);
    }

/**
     * Return the list of available drivers
     *
     * @return array
     */
    public function getAvailableDrivers()
    {
        $this->connectPdo();
        return $this->pdo->getAvailableDrivers();
    }

/**
     * return the last Id that was inserted into the database
     *
     * @param string $name
     * @return integer
     */
    public function lastInsertId($name=NULL)
    {
        if (!$this->isConnected()) {
            return null;
        }

return $this->pdo->lastInsertId($name);
    }

/**
     * Prepares the statement to be executed.
     *
     * Note: Using array type-hinting for $driverOptions will cause PHP E_STRICT
     * warnings in PHP 5.2.5.
     */
    public function prepare($query, $driverOptions = array())
    {
        $this->connectPdo();

$statement = $this->pdo->prepare($query, $driverOptions);
        return new My_Db_Statement($statement, $query, $this->profiler);
    }

/**
     * Executes a SQL query
     *
     * @param string $query
     */
    public function query($query)
    {
        $this->connectPdo();

$statement = $this->pdo->query($query);

return new My_Db_Statement($statement, $query);
    }

/**
     * Quote (escape) a string
     *
     * @param string $string
     * @param integer $parameter_type
     * @return string
     */
    public function quote(string $string, $parameter_type = PDO::PARAM_STR)
    {
        $this->connectPdo();
        return $this->pdo->quote($string, $parameter_type);
    }

/**
     * Roll back the current transaction
     *
     * @return boolean
     */
    public function rollBack()
    {
        if(!$this->inTransaction) {
            return false;
        }

$this->inTransaction = false;
        return $this->pdo->rollBack();
    }

/**
     * Set a PDO attribute
     *
     * @param integer $attribute
     * @param mixed $value
     */
    public function setAttribute(integer $attribute, $value)
    {
        $this->connectPdo();

$this->pdo->setAttribute($attribute, $value);
    }

}

Pretty simple really, just basically proxies calls to PDO. As you can see, before any operation that requires a database connection we call connectPdo() which will instantiate the PDO property of the database class if it hasn't been already. One other thing to note is that we also wrap the PDOStatement class as well so that it too can be mocked. Here's what that class looks like:

class My_Db_Statement
{
    protected $_statement;
    protected $query;

/**
     * Constructor.
     * @param PDOStatement $statement PDO statement handle.
     */
    public function __construct(PDOStatement $statement, $query)
    {
        $this->setStatement($statement);
        $this->query = $query;

return $this;
    }

/**
     * Sets the statement
     */
    protected function setStatement(PDOStatement $statement)
    {
        $this->_statement = $statement;
        return $this;
    }

/**
     * Retrieves the statement
     */
    protected function getStatement()
    {
        return $this->_statement;
    }

/**
     * Execute the statement
     */
    public function execute()
    {
        $result = $this->getStatement()->execute();

return $result;
    }

/**
     * Quick accessor for the PDO query string.
     * @return string
     */
    public function getQuery()
    {
        return $this->query;
    }

/**
     * Returns values in a single row with numerically indexed array.
     * @return array
     */
    public function fetch()
    {
        return $this->getStatement()->fetch(PDO::FETCH_NUM);
    }

/**
     * Returns values in a single row with associative array.
     * @return array
     */
    public function fetchAssoc()
    {
        return $this->getStatement()->fetch(PDO::FETCH_ASSOC);
    }

/**
     * Returns multidimensial array of all rows using numerically indexed
     * array.
     * @return array
     */
    public function fetchAll()
    {
        return $this->getStatement()->fetchAll(PDO::FETCH_NUM);
    }

/**
     * Returns multidimensional array of all rows using associative array.
     * @return array
     */
    public function fetchAllAssoc()
    {
        return $this->getStatement()->fetchAll(PDO::FETCH_ASSOC);
    }

/**
     * Returns true; binds values from out parameters to their variables.
     * @return bool
     */
    public function fetchBound()
    {
        return $this->getStatement()->fetch(PDO::FETCH_BOUND);
    }

/**
     * Binds a parameter by reference.  Conforms to PDO::bindParam()
     * @see PDOStatement::bindParam()
     */
    public function bindParam($param, &$value, $dataType = null)
    {
        if (is_null($dataType)) {
            $dataType = PDO::PARAM_STR;
        }
        return $this->getStatement()->bindParam($param, $value, $dataType);
    }

/**
     * Binds a parameter by reference.  Conforms to PDO::bindParam()
     * @see PDOStatement::bindParam()
     */
    public function bindParamInOut($param, &$value)
    {
        $dataType = PDO::PARAM_STR|PDO::PARAM_INPUT_OUTPUT;
        return $this->getStatement()->bindParam($param, $value, $dataType);
    }

/**
     * Binds a parameter by value.  Conforms to PDO::bindValue()
     * @see PDOStatement::bindValue()
     */
    public function bindValue($param, $value, $dataType = PDO::PARAM_STR)
    {
        return $this->getStatement()->bindValue($param, $value, $dataType);
    }
}

As you can see it's pretty much just a simple proxy as well, although I added a few methods to help with fetching records in different formats such as fetchAllAssoc(). The last thing I am going to show you is how I leverage these classes to mock out the database altogether and perform database tied tests without actually touching the database. As an example, here is a simple DAO (Data Access Object) that works with Widgets:

Here is my PHPUnit TestCase with a test method that covers the My_Widget_Dao::getById() method:

class My_Widget_DaoTest extends PHPUnit_Framework_TestCase
{
    /**
     * Test get a widget by id
     */
    public function testGetById()
    {
        // Get the mocked statement
        $mockStatement = $this->getMock('My_Db_Statement', array(), array(new PDOStatement(), null));

// We expect the execute method to be called on our statement ONCE
        $mockStatement->expects($this->once())
                      ->method('execute');

// We expect the bindValue method to be called on our statement ONCE
        // to look like this: $statement->bindValue(':id', 1);
        $mockStatement->expects($this->once())
                      ->method('bindValue')
                      ->with($this->equalTo(':id'), $this->equalTo(1));

// We expect the fetchAssoc method to be called on our statement ONCE 
        // and we want it to return the $record array below:
        $record = array(
            'id' => 1
        );

$mockStatement->expects($this->once())
                      ->method('fetchAssoc')
                      ->will($this->returnValue($record));

// We can only mock the prepare method because exec conflicts with PHPUnit
        $mockDb = $this->getMock('My_Db', array('prepare'), array('fake dsn!'));

// We expect the prepare method to be called on our mocked Db class ONCE
        // and we want it to return our mocked statement
        $mockDb->expects($this->once())
               ->method('prepare')
               ->will($this->returnValue($mockStatement));

// Instantiate the Dao and set its Db class to be our mocked Db class
        $dao = new My_Widget_Dao();
        $dao->setDbh($mockDb);

// Perform the action that we are testing.
        $result = $dao->getById(1);

// Ensure the returned result is what we expected
        $this->assertEquals($record, $result);
    }
}

That's all there is to it, I hope that clears up how to unit test when using PDO as your database abstraction layer.

Filed under: PHP No Comments

20Jun/080

Zend Framework Exception Handling

Handling exceptions is extremely import if you want to have an application that is stable and end-user friendly. The Zend Framework comes with some great features for handling things like missing controllers and actions right out of the box. Like many things with the Zend Framework, you have to dig a little before you find the answers that you need. There are three steps needed to take advantage of the build in exception handling features: 1) You have to register the Zend_Controller_Plugin_ErrorHandler plugin. 2) You have to create an error controller 3) You have to create the templates for the specific error types First is registering the plugin. That's super easy. For production, you probably want to turn off the front controller's abililty to throw exceptions. Next is my error controller. By default, the Zend_Controller_Plugin_ErrorHandler looks for the error controller in your default controllers directory. Mine is located at /modules/default/controllers/ErrorController.php and looks like this:

class ErrorController extends MDJP_Controller_Action
{
    /**
     * Should we display the errors?
     *
     * @var boolean
     */
    protected $_displayErrors = true;

/**
     * The error handler
     *
     * @var Zend_Controller_Plugin_ErrorHandler
     */
    protected $_error = null;

/**
     * Controller init method
     */
    public function init()
    {
        if ($this->getInvokeArg('displayErrors') == true) {
            $this->_displayErrors = true;
        }

$this->_error = $this->getRequest()->getParam('error_handler');
    }

/**
     * Default action of the Zend_Controller_Plugin_ErrorHandler
     */
    public function errorAction()
    {
        // Clear previous content
        $this->getResponse()->clearBody();

// This method delegates to others so there is no template for it
        $this->getHelper('ViewRenderer')->setNoRender();

switch ($this->_error->type) {
            case 'EXCEPTION_NO_CONTROLLER':
            case 'EXCEPTION_NO_ACTION':
                $this->_forward('not-found');
                return;
            case 'EXCEPTION_OTHER':
                $this->_forward('server-error');
                return;
        }
    }

/**
     * Handle a missing controller or action
     *
     * If displaying errors, we include the exception in the view variables
     */
    public function notFoundAction()
    {
        $this->_response->setHttpResponseCode(404);

if ($this->_displayErrors === true) {
            $this->view->ExceptionMessage = $this->_error->exception->getMessage();
        }
    }

/**
     * Handle an unknown server error
     *
     * If displaying errors we pass back the exception message and the traceback
     */
    public function serverErrorAction()
    {
        if ($this->_displayErrors === true) {
            $this->view->ExceptionMessage = $this->_error->exception->getMessage();

$rawTrace = array_reverse($this->_error->exception->getTrace());
            $traceback = array();
            $index = 0;
            foreach ($rawTrace as $traceEntry) {
                $tracebackArgs = '';
                if (array_key_exists('args', $traceback)) {
                    $tracebackArgs = implode(',', $traceback['args']);
                }

$traceback[] = '#'.$index++
                                .' '.$traceEntry['file']
                                .'('.$traceEntry['line'].')'
                                .' '.$traceEntry['class'].$traceEntry['type'].$traceEntry['function'].'('.$tracebackArgs.')';
            }

$this->view->Traceback = print_r(implode("\\n", $traceback), TRUE);
        }

// Always log errors
        $exception = $this->_error->exception;
        error_log($exception);

$this->_response->setHttpResponseCode(500);
    }
}

So the plugin will forward to the error action of your ErrorController. In there you can do anything you want, I choose to handle the 404 missing controller or action using a template and any other uncaught exceptions with a 500 server error which is also rendered out as a template. Here are those two templates: not-found.phtml server-error.phtml That's it. In case you are wondering where all of the HTML is in those templates, I use Zend_Layout so my action-based view scripts are quite minimal. Now you have a top level catch-all that can handle routing errors without having to write a "No Route" plugin and you get a top level exception handler in case you let one slip by you. Which would never happen of course ;)

Filed under: PHP No Comments

18Jun/080

Simple Array Syntax

So I was reading Brian Moon's blog today. I had bookmarked it to come back to it later but then I had to go to NY and everything... Turns out the change was voted down. The vote by email thing is lame as well.

So here's my opinion. Anything that makes PHP feel more like a modern programming language is better. What is the percentage of programmers that still code in C? Just because PHP is built on top of C doesn't mean that it has to look and feel like C. I totally agreed with Brian that it should be committed. In fact, I think the syntax should be expanded to include ranges:

$foo = [1,2,3,4,5];

could be written as:

$foo = [1..5];

Sweet. Oh and for the love of God can you make functions as first class citizens so we can start to do some functional programming?

*sigh* PHP is held back again.

Filed under: PHP No Comments

Older Entries »

About the Author

Matthew Purdon is a normal person, who does normal things. He occasionally works as a PHP developer for Schematic.

Categories

Code Naked
Programming
- PHP
  - Zend Framework
- Tools
Uncategorized

Archives

Meta