Model Caching

    Every application is different. In most applications though, there is data that changes infrequently. One of the most common bottlenecks in terms of performance, is accessing a database. This is due to the complex connection/communication processes that PHP perform with each request to obtain data from the database. Therefore, if we want to achieve good performance, we need to add some layers of caching where the application requires it.

    This chapter explains the potential areas where it is possible to implement caching to improve performance. Phalcon gives developers the tools they need to implement cashing where their application needs it.

    Caching Resultsets

    A well established technique to avoid continuously accessing the database, is to cache resultsets that don’t change frequently, using a system with faster access (usually memory).

    When requires a service to cache resultsets, it will request it from the Dependency Injection Container. The service name is called . Phalcon offers a cache component that can store any kind of data. We will now see how we can integrate it with our Models.

    First, we will need to register the cache component as a service in the DI container.

    Phalcon offers complete control in creating and customizing the cache component before registering it as a service in the DI container. Once the cache component is properly set up, resultsets can be cached as follows:

    1. <?php
    3. // Get products without caching
    4. $products = Products::find();
    6. // Just cache the resultset. The cache will expire in 1 hour (3600 seconds)
    7. $products = Products::find(
    8.     [
    9.         'cache' => [
    10.             'key' => 'my-cache',
    11.         ],
    12.     ]
    13. );
    15. // Cache the resultset for only for 5 minutes
    16. $products = Products::find(
    17.     [
    18.         'cache' => [
    19.             'key'      => 'my-cache',
    20.             'lifetime' => 300,
    21.         ],
    22.     ]
    23. );
    25. // Use the 'cache' service from the DI instead of 'modelsCache'
    26. $products = Products::find(
    27.     [
    28.         'cache' => [
    29.             'key'     => 'my-cache',
    30.             'service' => 'cache',
    31.         ],
    32.     ]
    33. );

    Caching could also be applied to resultsets generated using relationships:

    1. <?php
    3. // Query some post
    4. $post = Post::findFirst();
    6. // Get comments related to a post, also cache it
    7. $comments = $post->getComments(
    8.     [
    9.         'cache' => [
    10.             'key' => 'my-key',
    11.         ],
    12.     ]
    13. );
    15. // Get comments related to a post, setting lifetime
    16. $comments = $post->getComments(
    17.     [
    18.         'cache' => [
    19.             'key'      => 'my-key',
    20.             'lifetime' => 3600,
    21.         ],
    22.     ]
    23. );

    When a cached resultset needs to be invalidated, you can simply delete it from the cache using the key specified as seen above.

    Which resultset to cache and for how long is up to the developer, after having evaluated the needs of the application. Resultsets that change frequently should not be cached, since the cache results will be invalidated quickly. Additionally caching resultsets consumes processing cycles, therefore the cache that was intended to speed up the application actually slows it down. Resultsets that do not change frequently should be cached to minimize the database interactions. The decision on where to use caching and for how long is dictated by the application needs.

    Forcing Cache

    Earlier we saw how Phalcon\Mvc\Model integrates with the caching component provided by the framework. To make a record/resultset cacheable we pass the key cache in the array of parameters:

    1. <?php
    3. // Cache the resultset for only for 5 minutes
    4. $products = Products::find(
    5.     [
    6.         'cache' => [
    7.             'key'      => 'my-cache',
    8.             'lifetime' => 300,
    9.         ],
    10.     ]
    11. );

    This gives us the freedom to cache specific queries, however if we want to cache globally every query performed over the model, we can override the find()/findFirst() methods to force every query to be cached:

    1. <?php
    3. use Phalcon\Mvc\Model;
    5. class Robots extends Model
    6. {
    7.     /**
    8.      * Implement a method that returns a string key based
    9.      * on the query parameters
    10.      */
    11.     protected static function _createKey(array $parameters)
    12.     {
    13.         $uniqueKey = [];
    15.         foreach ($parameters as $key => $value) {
    16.             if (is_scalar($value)) {
    17.                 $uniqueKey[] = $key . ':' . $value;
    18.             } elseif (is_array($value)) {
    19.                 $uniqueKey[] = $key . ':[' . self::_createKey($value) . ']';
    20.             }
    21.         }
    23.         return join(',', $uniqueKey);
    24.     }
    26.     public static function find($parameters = null)
    27.     {
    28.         // Convert the parameters to an array
    29.         if (!is_array($parameters)) {
    30.             $parameters = [$parameters];
    31.         }
    33.         // Check if a cache key wasn't passed
    34.         // and create the cache parameters
    35.         if (!isset($parameters['cache'])) {
    36.             $parameters['cache'] = [
    37.                 'key'      => self::_createKey($parameters),
    38.                 'lifetime' => 300,
    39.             ];
    40.         }
    42.         return parent::find($parameters);
    43.     }
    45.     public static function findFirst($parameters = null)
    46.     {
    47.         // ...
    48.     }
    49. }

    This gives you full control on how the cache should be implemented for each model. If this strategy is common to several models you can create a base class for all of them:

    1. <?php
    3. use Phalcon\Mvc\Model;
    5. class CacheableModel extends Model
    6. {
    7.     protected static function _createKey(array $parameters)
    8.     {
    9.         // ... Create a cache key based on the parameters
    10.     }
    12.     public static function find($parameters = null)
    13.     {
    14.         // ... Custom caching strategy
    15.     }
    17.     public static function findFirst($parameters = null)
    18.     {
    19.         // ... Custom caching strategy
    20.     }
    21. }

    Then use this class as base class for each Cacheable model:

    1. <?php
    3. class Robots extends CacheableModel
    4. {
    6. }

    Regardless of the syntax we used to create them, all queries in the ORM are handled internally using PHQL. This language gives you much more freedom to create all kinds of queries. Of course these queries can be cached:

    1. <?php
    3. $phql = 'SELECT * FROM Cars WHERE name = :name:';
    5. $query = $this->modelsManager->createQuery($phql);
    7. $query->cache(
    8.     [
    9.         'key'      => 'cars-by-name',
    10.         'lifetime' => 300,
    11.     ]
    12. );
    14. $cars = $query->execute(
    15.     [
    16.         'name' => 'Audi',
    17.     ]
    18. );

    Some models may have relationships with other models. This allows us to easily check the records that relate to instances in memory:

    This example is very simple, a customer is queried and can be used as required, for example, to show its name. This also applies if we retrieve a set of invoices to show customers that correspond to these invoices:

    1. <?php
    3. // Get a set of invoices
    4. // SELECT * FROM invoices;
    5. $invoices = Invoices::find();
    7. foreach ($invoices as $invoice) {
    8.     // Get the customer related to the invoice
    9.     // SELECT * FROM customers WHERE id = ?;
    10.     $customer = $invoice->customer;
    12.     // Print his/her name
    13.     echo $customer->name, "\n";
    14. }

    A customer may have one or more bills so, in this example, the same customer record may be unnecessarily queried several times. To avoid this, we could mark the relationship as reusable; by doing so, we tell the ORM to automatically reuse the records from memory instead of re-querying them again and again:

    1. <?php
    3. use Phalcon\Mvc\Model;
    5. class Invoices extends Model
    6. {
    7.     {
    8.         $this->belongsTo(
    9.             'customers_id',
    10.             'Customer',
    11.             'id',
    12.             [
    14.             ]
    15.         );
    16.     }
    17. }

    Note that this type of cache works in memory only, this means that cached data are released when the request is terminated.

    When a related record is queried, the ORM internally builds the appropriate condition and gets the required records using find()/findFirst() in the target model according to the following table:

    This means that when you get a related record you could intercept how the data is obtained by implementing the corresponding method:

    1. <?php
    3. // Get some invoice
    4. $invoice = Invoices::findFirst();
    6. // Get the customer related to the invoice
    7. $customer = $invoice->customer; // Invoices::findFirst('...');
    9. // Same as above
    10. $customer = $invoice->getCustomer(); // Invoices::findFirst('...');

    Accordingly, we could replace the findFirst() method in the Invoices model and implement the cache we consider most appropriate:

    1. <?php
    3. use Phalcon\Mvc\Model;
    5. class Invoices extends Model
    6. {
    7.     public static function findFirst($parameters = null)
    8.     {
    9.         // ... Custom caching strategy
    10.     }
    11. }

    In this scenario, we assume that every time we query a result we also retrieve their associated records. If we store the records found together with their related entities perhaps we could reduce a bit the overhead required to obtain all entities:

    1. <?php
    3. use Phalcon\Mvc\Model;
    5. class Invoices extends Model
    6. {
    7.     protected static function _createKey($parameters)
    8.     {
    9.         // ... Create a cache key based on the parameters
    10.     }
    12.     protected static function _getCache($key)
    13.     {
    14.         // Returns data from a cache
    15.     }
    17.     protected static function _setCache($key, $results)
    18.     {
    19.         // Stores data in the cache
    20.     }
    22.     public static function find($parameters = null)
    23.     {
    24.         // Create a unique key
    25.         $key = self::_createKey($parameters);
    27.         // Check if there are data in the cache
    28.         $results = self::_getCache($key);
    30.         // Valid data is an object
    31.         if (is_object($results)) {
    32.             return $results;
    33.         }
    35.         $results = [];
    37.         $invoices = parent::find($parameters);
    39.         foreach ($invoices as $invoice) {
    40.             // Query the related customer
    41.             $customer = $invoice->customer;
    43.             // Assign it to the record
    44.             $invoice->customer = $customer;
    46.             $results[] = $invoice;
    47.         }
    49.         // Store the invoices in the cache + their customers
    50.         self::_setCache($key, $results);
    52.         return $results;
    53.     }
    55.     public function initialize()
    56.     {
    57.         // Add relations and initialize other stuff
    58.     }
    59. }
    1. <?php
    3. use Phalcon\Mvc\Model;
    5. class Invoices extends Model
    6. {
    7.     public function initialize()
    8.     {
    9.         // Add relations and initialize other stuff
    10.     }
    12.     protected static function _createKey($conditions, $params)
    13.     {
    14.         // ... Create a cache key based on the parameters
    15.     }
    17.     public function getInvoicesCustomers($conditions, $params = null)
    18.     {
    19.         $phql = 'SELECT Invoices.*, Customers.* FROM Invoices JOIN Customers WHERE ' . $conditions;
    21.         $query = $this->getModelsManager()->executeQuery($phql);
    23.         $query->cache(
    24.             [
    25.                 'key'      => self::_createKey($conditions, $params),
    26.                 'lifetime' => 300,
    27.             ]
    28.         );
    30.         return $query->execute($params);
    31.     }
    33. }

    Caching based on Conditions

    In this scenario, the cache is implemented differently depending on the conditions received. We might decide that the cache backend should be determined by the primary key:

    TypeCache Backend
    1 - 10000mongo1
    10000 - 20000mongo2
    > 20000mongo3

    The easiest way to achieve this is by adding a static method to the model that chooses the right cache to be used:

    1. <?php
    3. use Phalcon\Mvc\Model;
    5. class Robots extends Model
    6. {
    7.     public static function queryCache($initial, $final)
    8.     {
    9.         if ($initial >= 1 && $final < 10000) {
    10.             $service = 'mongo1';
    11.         } elseif ($initial >= 10000 && $final <= 20000) {
    12.             $service = 'mongo2';
    13.         } elseif ($initial > 20000) {
    14.             $service = 'mongo3';
    15.         }
    17.         return self::find(
    18.             [
    19.                 'id >= ' . $initial . ' AND id <= ' . $final,
    20.                 'cache' => [
    21.                     'service' => $service,
    22.                 ],
    23.             ]
    24.         );
    25.     }
    26. }

    This approach solves the problem, however, if we want to add other parameters such orders or conditions we would have to create a more complicated method. Additionally, this method does not work if the data is obtained using related records or a find()/findFirst():

    To achieve this we need to intercept the intermediate representation (IR) generated by the PHQL parser and thus customize the cache everything possible:

    The first is create a custom builder, so we can generate a totally customized query:

    1. <?php
    3. use Phalcon\Mvc\Model\Query\Builder as QueryBuilder;
    5. class CustomQueryBuilder extends QueryBuilder
    6. {
    7.     public function getQuery()
    8.     {
    9.         $query = new CustomQuery(
    10.             $this->getPhql()
    11.         );
    13.         $query->setDI(
    14.             $this->getDI()
    15.         );
    17.         if (is_array($this->_bindParams)) {
    18.             $query->setBindParams(
    19.                 $this->_bindParams
    20.             );
    21.         }
    23.         if (is_array($this->_bindTypes)) {
    24.             $query->setBindTypes(
    25.                 $this->_bindTypes
    26.             );
    27.         }
    29.         if (is_array($this->_sharedLock)) {
    30.             $query->setSharedLock(
    31.                 $this->_sharedLock
    32.             );
    33.         }
    35.         return $query;
    36.     }
    37. }

    Instead of directly returning a Phalcon\Mvc\Model\Query, our custom builder returns a CustomQuery instance, this class looks like:

    1. <?php
    3. use Phalcon\Mvc\Model\Query as ModelQuery;
    5. {
    6.     /**
    7.      * The execute method is overridden
    8.      */
    9.     public function execute($params = null, $types = null)
    10.     {
    11.         // Parse the intermediate representation for the SELECT
    12.         $ir = $this->parse();
    14.         if (is_array($this->_bindParams)) {
    15.             $params = array_merge(
    16.                 $this->_bindParams,
    17.                 (array) $params
    18.             );
    19.         }
    21.         if (is_array($this->_bindTypes)) {
    22.             $types = array_merge(
    23.                 $this->_bindTypes,
    24.                 (array) $types
    25.             );
    26.         }
    28.         // Check if the query has conditions
    29.         if (isset($ir['where'])) {
    30.             // The fields in the conditions can have any order
    31.             // We need to recursively check the conditions tree
    32.             // to find the info we're looking for
    33.             $visitor = new CustomNodeVisitor();
    35.             // Recursively visits the nodes
    36.             $visitor->visit(
    37.                 $ir['where']
    38.             );
    40.             $initial = $visitor->getInitial();
    41.             $final   = $visitor->getFinal();
    43.             // Select the cache according to the range
    44.             // ...
    46.             // Check if the cache has data
    47.             // ...
    48.         }
    50.         // Execute the query
    51.         $result = $this->_executeSelect($ir, $params, $types);
    52.         $result = $this->_uniqueRow ? $result->getFirst() : $result;
    54.         // Cache the result
    55.         // ...
    57.         return $result;
    58.     }
    59. }

    Implementing a helper (CustomNodeVisitor) that recursively checks the conditions looking for fields that tell us the possible range to be used in the cache:

    1. <?php
    3. class CustomNodeVisitor
    4. {
    5.     protected $_initial = 0;
    7.     protected $_final = 25000;
    9.     public function visit($node)
    10.     {
    11.         switch ($node['type']) {
    12.             case 'binary-op':
    13.                 $left  = $this->visit($node['left']);
    14.                 $right = $this->visit($node['right']);
    16.                 if (!$left || !$right) {
    17.                     return false;
    18.                 }
    20.                 if ($left === 'id') {
    21.                     if ($node['op'] === '>') {
    22.                         $this->_initial = $right;
    23.                     }
    25.                     if ($node['op'] === '=') {
    26.                         $this->_initial = $right;
    27.                     }
    29.                     if ($node['op'] === '>=') {
    30.                         $this->_initial = $right;
    31.                     }
    33.                     if ($node['op'] === '<') {
    34.                         $this->_final = $right;
    35.                     }
    37.                     if ($node['op'] === '<=') {
    38.                         $this->_final = $right;
    39.                     }
    40.                 }
    42.                 break;
    44.             case 'qualified':
    45.                 if ($node['name'] === 'id') {
    46.                     return 'id';
    47.                 }
    49.                 break;
    51.             case 'literal':
    52.                 return $node['value'];
    54.             default:
    55.                 return false;
    56.         }
    57.     }
    59.     public function getInitial()
    60.     {
    61.         return $this->_initial;
    62.     }
    64.     public function getFinal()
    65.     {
    66.         return $this->_final;
    67.     }
    68. }

    Finally, we can replace the find method in the Robots model to use the custom classes we’ve created:

    1. <?php
    3. use Phalcon\Mvc\Model;
    5. class Robots extends Model
    6. {
    7.     public static function find($parameters = null)
    8.     {
    9.         if (!is_array($parameters)) {
    10.             $parameters = [$parameters];
    11.         }
    13.         $builder = new CustomQueryBuilder($parameters);
    15.         $builder->from(
    16.             get_called_class()
    17.         );
    19.         $query = $builder->getQuery();
    21.         if (isset($parameters['bind'])) {
    22.             return $query->execute(
    23.                 $parameters['bind']
    24.             );
    25.         } else {
    26.             return $query->execute();
    27.         }
    28.     }
    29. }

    Caching PHQL execution plan

    As well as most moderns database systems PHQL internally caches the execution plan, if the same statement is executed several times PHQL reuses the previously generated plan improving performance, for a developer to take better advantage of this is highly recommended build all your SQL statements passing variable parameters as bound parameters:

    1. <?php
    3. for ($i = 1; $i <= 10; $i++) {
    4.     $phql = 'SELECT * FROM Store\Robots WHERE id = ' . $i;
    6.     $robots = $this->modelsManager->executeQuery($phql);
    8.     // ...
    9. }

    In the above example, ten plans were generated increasing the memory usage and processing in the application. Rewriting the code to take advantage of bound parameters reduces the processing by both ORM and database system:

    1. <?php
    3. $phql = 'SELECT * FROM Store\Robots WHERE id = ?0';
    5. for ($i = 1; $i <= 10; $i++) {
    6.     $robots = $this->modelsManager->executeQuery(
    7.         $phql,
    8.         [
    9.             $i,
    10.         ]
    11.     );
    13.     // ...
    14. }

    Performance can be also improved reusing the PHQL query:

    1. <?php
    3. $phql = 'SELECT * FROM Store\Robots WHERE id = ?0';
    5. $query = $this->modelsManager->createQuery($phql);
    7. for ($i = 1; $i <= 10; $i++) {
    8.     $robots = $query->execute(
    9.         $phql,
    10.         [
    11.             $i,
    12.         ]
    13.     );
    15. }