Sameer Parwani

The Zend Framework provides a Zend_Cache which can be plugged into with various backends such as SQLite, Memcached, APC, and so on. Separately, it also provides Zend_Registry which is a “a container for storing objects and values in the application space”. The Zend_Registry is not a cache as its contents are created and used only by the currently executing script.

So, why would you want to use the Registry as a cache when it does not cache anything between page loads? The answer is to provide a transition point for caching additional data in other Zend_Cache backends.

For example, every time a Zend_Db_Table is instatiated it runs a DESCRIBE TABLE query which is a surprisingly expensive query (or at least it was surprising to me). If you are using the MVC model, you can end up running this query dozens of times on one page. So to speed things up you should cache the results of the DESCRIBE TABLE query. You will end up improving performance whether you save the results in the Registry or (even better) in an appropriate Zend_Cache backend.

However, at the moment you have not configured your Memcached daemon so you instead decide to use the Zend_Registry. But Zend_Registry does not follow the same syntax as Zend_Cache. So, when you do finally set up Memcached you will have to go back, edit your code to follow the Zend_Cache sytanx, and then test your cache. It’s better to instead use Zend_Registry as a backend to Zend_Cache which will make it utterly simple to change the cache backend to Memcached at a later date.

And, if you ever are not sure whether its worthwhile (or logically appropriate) to cache data in a persistant cache, having Zend_Registry as a backend allows you to experiment quickly and then later make the change to a different backend.

Note: Because of the short life of Zend_Registry as a cache, I did not implement expiration times nor tags.

<?php

/**
* @see Zend_Cache_Backend_Interface
*/
require_once 'Zend/Cache/Backend/Interface.php';

/**
* @see Zend_Cache_Backend
*/
require_once 'Zend/Cache/Backend.php';

/**
* @package    Zend_Cache
* @subpackage Zend_Cache_Backend
* @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
* @license    http://framework.zend.com/license/new-bsd     New BSD License
*/
class Zend_Cache_Backend_Registry extends Zend_Cache_Backend implements Zend_Cache_Backend_Interface
{

// array name for the registry entries
protected static $_registeryCacheArrayName = "registryCacheArray";

// a static instance of the registry
protected static $_registryCacheArray;

/**
* Constructor
*
* @param  array $options associative array of options
* @throws Zend_Cache_Exception
* @return void
*/
public function __construct($options = array())
{
    parent::__construct($options);
    $registry = Zend_Registry::getInstance();
    if (!isset($registry[self::$_registeryCacheArrayName])) $registry[self::$_registeryCacheArrayName] = array();
    // copy by reference
    self::$_registryCacheArray = $registry[self::$_registeryCacheArrayName];
}

/**
* Test if a cache is available for the given id and (if yes) return it (false else)
*
*
* @param  string  $id                     cache id
* @param  boolean $doNotTestCacheValidity if set to true, the cache validity won't be tested
* @return string cached datas (or false)
*/
public function load($id, $doNotTestCacheValidity = false)
{
    if (!isset(self::$_registryCacheArray[$id])) return false;
    else return self::$_registryCacheArray[$id];
}

/**
* Test if a cache is available or not (for the given id)
*
* @param  string $id cache id
* @return boolean true if exists false if not
*/
public function test($id)
{
    return isset(self::$_registryCacheArray[$id]);
}

/**
* Save some string datas into a cache record
*
* Note : $data is always "string" (serialization is done by the
* core not by the backend)
*

* @param string $data datas to cache
* @param string $id cache id
* @param array $tags array of strings, the cache record will be tagged by each string entry
* @param int $specificLifetime if != false, set a specific lifetime for this cache record (null => infinite lifetime)
* @return boolean true if no problem
*/
public function save($data, $id, $tags = array(), $specificLifetime = false)
{
    self::$_registryCacheArray[$id] = $data;
    if (count($tags) > 0) {
        $this->_log("Zend_Cache_Backend_Registry::save() : tags are unsupported by the registry backend");

    }
    return true;
}

/**
* Remove a cache record
*
* @param  string $id cache id
* @return boolean true if no problem
*/
public function remove($id)
{
    unset(self::$_registryCacheArray[$id]);
}

/**
* Clean some cache records
*
* Available modes are :
* 'all' (default)  => remove all cache entries ($tags is not used)
* 'old'            => remove too old cache entries ($tags is not used)
* 'matchingTag'    => remove cache entries matching all given tags
*                     ($tags can be an array of strings or a single string)
* 'notMatchingTag' => remove cache entries not matching one of the given tags
*                     ($tags can be an array of strings or a single string)
*
* @param  string $mode clean mode
* @param  array  $tags array of tags
* @return boolean true if no problem
*/
public function clean($mode = Zend_Cache::CLEANING_MODE_ALL, $tags = array())
{
    if ($mode==Zend_Cache::CLEANING_MODE_ALL) {
        self::$_registryCacheArray = array();
    }
    if ($mode==Zend_Cache::CLEANING_MODE_OLD) {
        $this->_log("Zend_Cache_Backend_registry::clean() : CLEANING_MODE_OLD is unsupported by the registry backend");

    }
    if ($mode==Zend_Cache::CLEANING_MODE_MATCHING_TAG) {
        $this->_log("Zend_Cache_Backend_registry::clean() : tags are unsupported by the registry backend");

    }
    if ($mode==Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG) {
        $this->_log("Zend_Cache_Backend_registry::clean() : tags are unsupported by the registry backend");

    }
}

/**
* Return true if the automatic cleaning is available for the backend
*
* @return boolean
*/
public function isAutomaticCleaningAvailable()
{
    return false;
}

}

And to use Zend_Cache to cache DESCRIBE TABLE queries:

class MyZend_Db_Table extends Zend_Db_Table {

protected static $metadataCache;

public function __construct($config = array())
{
if (!self::$metadataCache) {
self::$metadataCache = Zend_Cache::factory('Core', 'Registry', array('automatic_serialization' => true));
}

if (!isset($config[self::METADATA_CACHE])) $config[self::METADATA_CACHE] = self::$metadataCache;
parent::__construct($config);

}
}

Just remember that your own Db Tables should then extend MyZend_Db_Table and not Zend_Db_Table.