15.2.1 Memcache

Memcache driver stores cache records into a memcached server. Memcached is a high-performance, distributed memory object
caching system. In order to use this backend, you need a memcached daemon and the memcache PECL extension.

Listing 15.2

<?php

// memcache allows multiple servers
$servers = array('host' => 'localhost',
                 'port' => 11211,
                 'persistent' => true);

$cacheDriver = new Doctrine_Cache_Memcache(array('servers' => $servers,
                                           'compression' => false));

?>

Available options for Memcache driver:

servers ; each memcached server is described by an associative array : 'host' => (string) : the name of the memcached
server, 'port' => (int) : the port of the memcached server, 'persistent' => (bool) : use or not persistent connections
to this memcached server ||

15.2.2 APC

The Alternative PHP Cache (APC) is a free and open opcode cache for PHP. It was conceived of to provide a free, open, and
robust framework for caching and optimizing PHP intermediate code.

The APC cache driver of Doctrine stores cache records in shared memory.

Listing 15.3

<?php

$cacheDriver = new Doctrine_Cache_Apc();

?>

15.2.3 Db

Db caching backend stores cache records into given database. Usually some fast flat-file based database is used (such as
sqlite).

Initializing sqlite cache driver can be done as above:

Listing 15.4

<?php

$conn  = Doctrine_Manager::connection(new PDO('sqlite::memory:'));

$cacheDriver = new Doctrine_Cache_Sqlite(array('connection' => $conn));

?>

15.3.1 Introduction

Doctrine provides means for caching the results of the DQL parsing process, as well as the end results of DQL queries (the
data). These two caching mechanisms can greatly increase performance. Consider the standard workflow of DQL query execution:

1. Init new DQL query
2. Parse DQL query
3. Build database specific SQL query
4. Execute the SQL query
5. Build the result set
6. Return the result set

Now these phases can be very time consuming, especially phase 4 which sends the query to your database server. When
Doctrine query cache is being used only the following phases occur:

1. Init new DQL query
2. Execute the SQL query (grabbed from the cache)
3. Build the result set
4. Return the result set

If a DQL query has a valid cache entry the cached SQL query is used, otherwise the phases 2-3 are executed normally and
the result of these steps is then stored in the cache.
The query cache has no disadvantages, since you always get a fresh query result. You should therefore always use it in a
production environment. That said, you can easily use it during development, too. Whenever you change a DQL query and
execute it the first time Doctrine sees that is has been modified and will therefore create a new cache entry, so you
dont even need to invalidate the cache. It's worth noting that the effectiveness of the query cache greatly relies on
the usage of prepared staments (which are used by Doctrine by default anyway). You should not directly embed dynamic
query parts and always use placeholders instead.

When using a result cache things get even better. Then your query process looks as follows (assuming a valid cache entry
is found):

1. Init new DQL query
2. Return the result set

As you can see, the result cache implies the query cache shown previously.
You should always consider using a result cache if the data returned by the query does not need to be up-to-date at any
time.

15.3.2 Query Cache

<?php

$manager = Doctrine_Manager::getInstance();

$manager->setAttribute(Doctrine::ATTR_QUERY_CACHE, $cacheDriver);

?>

<?php

$manager = Doctrine_Manager::getInstance();
$conn    = $manager->openConnection('pgsql://user:pass@localhost/test');

$conn->setAttribute(Doctrine::ATTR_QUERY_CACHE, $cacheDriver);

?>

<?php

$query = Doctrine_Query::create()
          ->useQueryCache(new Doctrine_Cache_Apc());

?>

15.3.3 Result Cache

<?php

$manager = Doctrine_Manager::getInstance();

$manager->setAttribute(Doctrine::ATTR_RESULT_CACHE, $cacheDriver);

?>

<?php

$manager = Doctrine_Manager::getInstance();
$conn    = $manager->openConnection('pgsql://user:pass@localhost/test');

$conn->setAttribute(Doctrine::ATTR_RESULT_CACHE, $cacheDriver);

?>

<?php

$manager = Doctrine_Manager::getInstance();

// set the lifespan as one hour (60 seconds * 60 minutes = 1 hour = 3600 secs)
$manager->setAttribute(Doctrine::ATTR_RESULT_CACHE_LIFESPAN, 3600);

?>

<?php

$query = Doctrine_Query::create();

// fetch blog titles and the number of comments
$query->select('b.title, COUNT(c.id) count')
      ->from('Blog b')
      ->leftJoin('b.Comments c')
      ->limit(10)
      ->useResultCache(true);

$entries = $query->execute();

?>

<?php

$query = Doctrine_Query::create();

$query->useResultCache(new Doctrine_Cache_Apc());

?>

<?php

$query = Doctrine_Query::create();

// set the lifespan as half an hour
$query->setResultCacheLifeSpan(60 * 30);

?>