Definitely, one of the nicest features of PHP is the ability to serialize and unserialize data. This two-way process is easily accomplished by the function "serialize()" and its counterpart "unserialize()". In short, when a PHP value is serialized, a string representation of its type and structure is obtained. This is useful for storing different data structures as byte-stream strings, and then, by reversing the operation, restoring them to their original types and structure.

These operations are commonly used when working with objects, when one or more objects are serialized to work with sessions, saving their properties but not the methods. However, using a workaround, it's possible to restore an object from a serialized state and still have its methods available.

As PHP allows you to quickly serialize several values, we'll use this ability as the primary base for building a result set caching script. The logic of the script is fairly easy to understand by the following sequence: we connect to MySQL and perform a SELECT statement, retrieving a result set, whose values are saved into an array. Then, we simply serialize the array, and finally store it in a cache file. Simple, right?

According to the above explanation, a basic version of a result set caching script would look like this:

// connect to MySQL
$db=mysql_connect('host','user','password') or die('Error
connecting to the server '.mysql_error());
// select database
mysql_select_db('databasename',$db) or die('Error selecting
database '.mysql_error());
// perform query
$result=mysql_query('SELECT * FROM users') or die('Error
performing query '.mysql_error());
// store rows in array
while($row=mysql_fetch_array($result,MYSQL_ASSOC)){
    $results[]=$row;
}
// store serialized results in cache file
$cacheFile='cacheFile.txt';
$fp=fopen($cacheFile,'w') or die('Error opening cache file');
fwrite($fp,serialize($results));
fclose($fp);
unset($fp,$cacheFile);
// display rows
foreach($results as $key=>$row){
    echo $row['firstname'].'&nbsp;'.$row['lastname'].'<br />';
}

As you can see, the script is extremely simple in its current incarnation. It connects to MySQL, and executes a SELECT statement against a sample "users" table, obtaining a result set. Next, it saves the data in the "results" array, which is serialized and stored in a sample cache file. Doing so, a byte-stream representation of the array is now saved in the given file.

Finally, the data is displayed using a regular "foreach" loop, showing the first and last name of some selected users. Indeed the whole script flow is easy to follow.

Despite the fact that the snippet is very simple, it's quite good at illustrating the core logic behind this result set caching system. However, until now nothing has been gained in terms of improved performance, for the sole reason that the script is not taking advantage of the cached data. Each time the code is executed, the same steps will be carried out, storing the result set in the cache file.

Surely you'll agree that, with a result set saved to a file, it's fairly easy to introduce some modifications to the above script and make the cache work properly. Therefore, let's change some of the script's code and put the caching system to work.