lib/AkCache/AkAdodbCache.php

   1 <?php
   2 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
   3
   4 // +----------------------------------------------------------------------+
   5 // | Akelos Framework - http://www.akelos.org                             |
   6 // +----------------------------------------------------------------------+
   7 // | Copyright (c) 2002-2006, Akelos Media, S.L.  & Bermi Ferrer Martinez |
   8 // | Released under the GNU Lesser General Public License, see LICENSE.txt|
   9 // +----------------------------------------------------------------------+
  10
  11 /**
  12  * @package ActiveSupport
  13  * @subpackage Cache
  14  * @author Bermi Ferrer <bermi a.t akelos c.om>
  15  * @copyright Copyright (c) 2002-2006, Akelos Media, S.L. http://www.akelos.org
  16  * @license GNU Lesser General Public License <http://www.gnu.org/copyleft/lesser.html>
  17  */
  18
  19
  20 if(!defined('AK_ADODBCACHE_CLASS_INCLUDED')){ define('AK_ADODBCACHE_CLASS_INCLUDED',true); // Class overriding trick
  21
  22 // ---- Required Files ---- //
  23 require_once(AK_LIB_DIR.'/Ak.php');
  24
  25
  26 /**
  27 * Dabase cache driver for the AkCache class
  28 *
  29 * @author Bermi Ferrer <bermi at akelos dot com>
  30 * @copyright Copyright (c) 2002-2006, Akelos Media, S.L. http://www.akelos.org
  31 * @license GNU Lesser General Public License <http://www.gnu.org/copyleft/lesser.html>
  32 */
  33 class AkAdodbCache
  34 {
  35     // {{{ properties
  36
  37
  38     // --- Private properties --- //
  39
  40
  41     /**
  42     * Handles an instance of current database conection using
  43     * AdoBD
  44     *
  45     * @see setDb
  46     * @access private
  47     * @var object $_db
  48     */
  49     var $_db = NULL;
  50
  51     /**
  52     * Timestamp of the last valid cache
  53     *
  54     * @see setRefreshTime
  55     * @access private
  56     * @var integer $_refreshTime
  57     */
  58     var $_refreshTime = NULL;
  59
  60     /**
  61     * Cache lifetime (in seconds)
  62     *
  63     * @see setLifeTime
  64     * @access private
  65     * @var integer $_lifeTime
  66     */
  67     var $_lifeTime = 3600;
  68
  69     /**
  70     * Enable / Disable "Memory Caching"
  71     *
  72     * NB : There is no lifetime for memory caching !
  73     *
  74     * @see setMemoryCaching
  75     * @access private
  76     * @var boolean $_memoryCaching
  77     */
  78     var $_memoryCaching = false;
  79
  80     /**
  81     * Memory caching container array
  82     *
  83     * @access private
  84     * @var array $_memoryCachingArray
  85     */
  86     var $_memoryCachingArray = array();
  87
  88     /**
  89     * Enable / disable automatic serialization
  90     *
  91     * It can be used to save directly datas which aren't strings
  92     * (but it's slower)
  93     *
  94     * @see setAutomaticSerialization
  95     * @access private
  96     * @var boolean $_automaticSerialization
  97     */
  98     var $_automaticSerialization = false;
  99
 100     // }}}
 101
 102
 103
 104     // ------ CLASS METHODS ------ //
 105
 106
 107
 108     // ---- Setters ---- //
 109
 110
 111     // {{{ setDb()
 112
 113     /**
 114     * $this->_db setter
 115     *
 116     * Use this method to set $this->_db value
 117     *
 118     * @access public
 119     * @see get$db
 120     * @param    object    $db    Handles an instance of current database conection
 121     * using AdoBD
 122     * @return void
 123     */
 124     function setDb($db)
 125     {
 126         $this->_db = $db;
 127
 128     }
 129
 130     // }}}
 131     // {{{ setRefreshTime()
 132
 133     /**
 134     * $this->_refreshTime setter
 135     *
 136     * Use this method to set $this->_refreshTime value
 137     *
 138     * @access public
 139     * @see get$refreshTime
 140     * @param    integer    $refresh_time    Timestamp of the last valid cache
 141     * @return void
 142     */
 143     function setRefreshTime($refresh_time)
 144     {
 145         $this->_refreshTime = $refresh_time;
 146
 147     }
 148
 149     // }}}
 150     // {{{ setLifeTime()
 151
 152     /**
 153     * $this->_lifeTime setter
 154     *
 155     * Use this method to set $this->_lifeTime value
 156     *
 157     * @access public
 158     * @see get$lifeTime
 159     * @param    integer    $life_time    Cache lifetime (in seconds)
 160     * @return void
 161     */
 162     function setLifeTime($life_time = 3600)
 163     {
 164         $this->_lifeTime = $life_time;
 165         $this->setRefreshTime(time() - $this->_lifeTime);
 166     }
 167
 168     // }}}
 169     // {{{ setMemoryCaching()
 170
 171     /**
 172     * $this->_memoryCaching setter
 173     *
 174     * Use this method to set $this->_memoryCaching value
 175     *
 176     * @access public
 177     * @see get$memoryCaching
 178     * @param    boolean    $memory_caching    Enable / Disable "Memory Caching"
 179     *
 180     * NB : There is no lifetime for memory caching !
 181     * @return void
 182     */
 183     function setMemoryCaching($memory_caching = false)
 184     {
 185         $this->_memoryCaching = (bool)$memory_caching;
 186
 187     }
 188
 189     // }}}
 190     // {{{ setAutomaticSerialization()
 191
 192     /**
 193     * $this->_automaticSerialization setter
 194     *
 195     * Use this method to set $this->_automaticSerialization value
 196     *
 197     * @access public
 198     * @see get$automaticSerialization
 199     * @param    boolean    $automatic_serialization    Enable / disable automatic serialization
 200     * @return void
 201     */
 202     function setAutomaticSerialization($automatic_serialization = false)
 203     {
 204         $this->_automaticSerialization = (bool)$automatic_serialization;
 205
 206     }
 207
 208     // }}}
 209
 210
 211     // ---- Public methods ---- //
 212
 213
 214     // {{{ init()
 215
 216     /**
 217     * Class constructor (ALA Akelos Framework)
 218     *
 219     * @access public
 220     * @param    array    $options
 221     * <code>
 222     * $options = array(
 223     * //This options are valid for both cache contains (database and file based)
 224     * 'lifeTime' => cache lifetime in seconds (int),
 225     * 'memoryCaching' => enable / disable memory caching (boolean),
 226     * 'automaticSerialization' => enable / disable automatic serialization (boolean)
 227     * );
 228     * </code>
 229     * @return void
 230     */
 231     function init($options = array())
 232     {
 233         $this->_db =& Ak::db();
 234
 235         $available_options = array('memoryCaching', 'lifeTime', 'automaticSerialization');
 236         foreach($options as $key => $value) {
 237             if(in_array($key, $available_options)) {
 238                 $property = '_'.$key;
 239                 $this->$property = $value;
 240             }
 241         }
 242         $this->_refreshTime = time() - $this->_lifeTime;
 243     }
 244
 245     // }}}
 246     // {{{ get()
 247
 248     /**
 249     * Test if a cache is available and (if yes) return it
 250     *
 251     * @access public
 252     * @param    string    $id    Cache id
 253     * @param    string    $group    Name of the cache group.
 254     * @return mixed Data of the cache (or false if no cache available)
 255     */
 256     function get($id, $group = 'default')
 257     {
 258         $this->_id = $id;
 259         $this->_group = $group;
 260         $cache_hash = md5($this->_id).'_'.md5($this->_group);
 261
 262         if(isset($this->_memoryCachingArray[$cache_hash])){
 263             return $this->_memoryCachingArray[$cache_hash];
 264         }
 265
 266         $query_result = $this->_db->Execute('
 267             SELECT cache_data
 268             FROM cache
 269             WHERE id = '.$this->_db->qstr($cache_hash).'
 270             AND cache_group = '.$this->_db->qstr($this->_group).'
 271             AND expire > '.$this->_db->DBTimeStamp($this->_refreshTime)
 272         );
 273
 274         if(!$query_result && AK_DEBUG){
 275             trigger_error($this->_db->ErrorMsg(), E_USER_NOTICE);
 276         }else{
 277
 278             $data = $this->_db->BlobDecode($query_result->fields[0]);
 279
 280             if($this->_automaticSerialization == true){
 281                 $data = unserialize($data);
 282             }
 283
 284             if($this->_memoryCaching){
 285                 $this->_memoryCachingArray[$cache_hash] = $data;
 286             }
 287
 288             return $data;
 289         }
 290
 291         return false;
 292     }
 293
 294
 295     // }}}
 296     // {{{ save()
 297
 298     /**
 299     * Save some data in the cache
 300     *
 301     * @access public
 302     * @param    string    $data    Data to put in cache
 303     * @param    string    $id    Cache id. By default it will use the Id specified
 304     * when calling $this->get
 305     * @param    string    $group    Name of the cache group. By default it will use
 306     * the group specified when calling $this->get
 307     * @return boolean True if no problem
 308     */
 309     function save($data, $id = null, $group = null)
 310     {
 311         $this->_id = isset($id) ? $id : $this->_id;
 312         $this->_group = isset($group) ? $group : $this->_group;
 313
 314         $cache_hash = md5($this->_id).'_'.md5($this->_group);
 315
 316         if($this->_automaticSerialization == true){
 317             $data = serialize($data);
 318         }
 319
 320         $ret = $this->_db->Replace(
 321         'cache', array(
 322         'id'=>$this->_db->qstr($cache_hash),
 323         'cache_data'=>$this->_db->qstr($this->_db->BlobEncode($data)),
 324         'cache_group'=>$this->_db->qstr($this->_group),
 325         'expire'=>$this->_db->DBTimeStamp(time() + $this->_lifeTime)),
 326         'id');
 327
 328         if($ret == 0){
 329             return false;
 330         }else{
 331             if($this->_memoryCaching){
 332                 $this->_memoryCachingArray[$cache_hash] = $data;
 333             }
 334             return true;
 335         }
 336     }
 337
 338     // }}}
 339     // {{{ remove()
 340
 341     /**
 342     * Remove a cache item from the database
 343     *
 344     * @access public
 345     * @param    string    $id    Cache id
 346     * @param    string    $group    Name of the cache group
 347     * @return boolean True if no problem
 348     */
 349     function remove($id, $group = 'default')
 350     {
 351         $cache_hash = md5($id).'_'.md5($group);
 352
 353         if (isset($this->_memoryCachingArray[$cache_hash])) {
 354             unset($this->_memoryCachingArray[$cache_hash]);
 355         }
 356         if(!$this->_db->Execute('DELETE FROM cache WHERE id = '.$this->_db->qstr($cache_hash)) && AK_DEBUG){
 357             trigger_error($this->_db->ErrorMsg(), E_USER_NOTICE);
 358         }
 359         return (bool)$this->_db->Affected_Rows();
 360     }
 361
 362     // }}}
 363     // {{{ clean()
 364
 365     /**
 366     * Clean the cache
 367     *
 368     * If no group is specified all cache items  will be removed
 369     * from the database else only cache items of the specified
 370     * group will be destroyed
 371     *
 372     * @access public
 373     * @param    string    $group    If no group is specified all cache items  will be
 374     * removed from the database else only cache items
 375     * of the specified group will be destroyed
 376     * @param    string    $mode    Flush cache mode. Options are:
 377     *
 378     * - old
 379     * - ingroup
 380     * - notingroup
 381     * @return boolean True if no problem
 382     */
 383     function clean($group = false, $mode = 'ingroup')
 384     {
 385         switch ($mode) {
 386             case 'ingroup':
 387             if(!$this->_db->Execute('DELETE FROM cache WHERE cache_group = '.$this->_db->qstr($group)) && AK_DEBUG){
 388                 trigger_error($this->_db->ErrorMsg(), E_USER_NOTICE);
 389             }
 390             return (bool)$this->_db->Affected_Rows();
 391             case 'notingroup':
 392
 393             if(!$this->_db->Execute('DELETE FROM cache WHERE cache_group NOT LIKE '.$this->_db->qstr($group)) && AK_DEBUG){
 394                 trigger_error($this->_db->ErrorMsg(), E_USER_NOTICE);
 395             }
 396             return (bool)$this->_db->Affected_Rows();
 397             case 'old':
 398
 399             if(!$this->_db->Execute('DELETE FROM cache WHERE expire < '.$this->_db->DBTimeStamp(time())) && AK_DEBUG){
 400                 trigger_error($this->_db->ErrorMsg(), E_USER_NOTICE);
 401             }
 402             return (bool)$this->_db->Affected_Rows();
 403             default:
 404             return true;
 405         }
 406     }
 407
 408     // }}}
 409
 410 }
 411
 412 }// End of if(!defined('AK_ADODBCACHE_CLASS_INCLUDED')){
 413
 414 ?>