Zend Framework, being as flexible as it is, is ripe for plenty of tips and tricks. I know I've seen a lot of quirky, undocumented things that people put in their apps. I'd love for people to share their creative coding tricks using ZF.
There is a similar thread to this with Django that I found very helpful, so I thought I would start one of these for Zend Framework.
Zend Framework includes database adapters for some non-PDO PHP extensions:
In spite of the documentation, I'm always surprised by people who are under the impression that only PDO is supported.
Zend_Db makes a lazy connection to the database. You can instantiate a Zend_Db_Adapter object any time you want, but it doesn't connect to the database unless and until you prepare a query, or call the getConnection() method on the adapter object.
Integration with Firebug.
Trivially easy to dump structured data to the Firebug console.
Just as easy to profile database activity and dump a table of queries to Firebug again.
Just one of the many ways ZF saves time and makes life easy.
Controller Action Helpers are not very well known but provide some really useful on demand functionality.
My two favourites are FlashMessenger, for easily passing messages to other pages, and ContextSwitch, for providing different response formats based on request data.
My 3rd and final (for now) is Zend_Form
I've spoken to people using Zend Framework but not using Zend Form. It is without doubt one of the best components in the framework, providing trivially easy form generation, filtering and validation. It's also easy to add custom elements, decorators, validators and filters,
Though the documentation is long, it's very easy to get started with and you'll soon enjoy rapid development of forms across your application.
Zend_Auth_Adapter and Zend_Auth_Storage are quite configurable - you don't have to stick with the builtins. For example, I'm twitter as my auth adapter backend!
Adding caching to Zend_Db_Table_Abstract classes is really easy.
class foo extends Zend_Db_Table_Abstract to class foo extends CachingTableclass CachingTable extends Zend_Db_Table_Abstract and overwrite methods update, insert, delete, fetchRow and fetchAllinit methodmd5($where->__toString()) as caching identifier in fetchAll and fetchRow$this->_purgeCache() on update, insert and deleteExample code:
This example caches all select queries indefinitely and any insert/update/delete purges all cached stuff.
To Bootstrap:
// Caching
$cache_config = new Zend_Config_Ini(dirname(__FILE__) . '/../config.ini', 'cache');
$frontendOptions = array(
'caching' => true,
'lifetime' => null,
'automatic_serialization' => true
);
$backendOptions = array(
'cache_dir' => $cache_config->directory,
'cache_file_umask' => 0607
);
$cache = Zend_Cache::factory('Core', 'File', $frontendOptions, $backendOptions);
Zend_Registry::set('Cache', $cache);
Where you keeps your extensions:
class CachingTable extends Zend_Db_Table_Abstract
{
/**
* @var Zend_Cache
*/
protected $_cache = null;
/**
* @var bool
*/
public $cache_result = true;
/**
* Initialize
*/
public function init()
{
// Get from bootstrap
$this->_cache = Zend_Registry::get('Cache');
} // /function
/**
* Reset cache
*/
public function _purgeCache()
{
$this->_cache->clean(Zend_Cache::CLEANING_MODE_ALL);
} // /function
/**
* update
*/
public function update(array $data, $where)
{
parent::update($data, $where);
$this->_purgeCache();
} // /function
/**
* insert
*/
public function insert(array $data)
{
parent::insert($data);
$this->_purgeCache();
} // /function
/**
* delete
*/
public function delete($where)
{
parent::delete($where);
$this->_purgeCache();
} // /function
/**
* Fetch all
*/
public function fetchAll($where = null, $order = null, $count = null, $offset = null)
{
$id = md5($where->__toString());
if ((!($this->_cache->test($id))) || (!$this->cache_result))
{
$result = parent::fetchAll($where, $order, $count, $offset);
$this->_cache->save($result);
return $result;
}
else
{
return $this->_cache->load($id);
}
} // /function
/**
* Fetch one result
*/
public function fetchRow($where = null, $order = null)
{
$id = md5($where->__toString());
if ((!($this->_cache->test($id))) || (!$this->cache_result))
{
$result = parent::fetchRow($where, $order);
$this->_cache->save($result);
return $result;
}
else
{
return $this->_cache->load($id);
}
} // /function
} // /class
Where you keep database-related stuff:
/**
* Pages
*/
class Pages extends CachingTable
{
/**
* Table name
* @var string
*/
protected $_name = 'PAGES';
/**
* Primary key
* @var string
*/
protected $_primary = 'name';
} // /class
In your actual controller / model / view / whatever:
$pages = new Pages();
//$pages->cache_result = false; // Don't cache
$select = $pages->select();
$select->from($pages, array('content'));
$select->where('name = ?', $page);
$info = $pages->fetchRow($select);
if(!is_null($info))
{
$info = $info->toArray();
}
else
{
// Add new page
$pages->insert(array('name' => $page, 'added' => new Zend_Db_Expr('NOW()'), 'updated' => new Zend_Db_Expr('NOW()')));
}
Zend_Db_Adapter has a method quoteIdentifier() which allows you to use table names and column names that contain special characters, whitespace, SQL keywords, etc.
Quoting identifiers is different from quoting data values, and different brands of database quote identifiers in different ways.
I haven't seen any other framework or database access library that provides a function for quoting identifiers.
Zend_Db_Table_Row has a function _transformColumn that can be used to convert column names. We have a custom record class that extends Zend_Db_Table_Row that we use to enforce coding guidlines (in the database a column post_id would be transformed to postId in the application).
I ran some quick tests and found the pdo adapter performed better in our application than mysqli (contrary to other tests found on the internet). Would like to know if this has been the experience of others as well. Blog post of results
Turn on MYSQL_ATTR_USE_BUFFERED_QUERY if you're running MySQL before version 5.1.17.
$pdoParams = array( PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true );
This will enable the MySQL query cache which is turned off due to prepared statement use w/ Zend Framework.
Using front controller singleton as an alternative to registry:
$front = Zend_Controller_Front::getInstance();
$front->setParam('yourUniqueID', $anything);
Then, (almost) anywhere in the app:
$this->getFrontController()->getParam('yourUniqueID');
or:
$front = Zend_Controller_Front::getInstance();
$front->getParam('yourUniqueID');