system/libraries/drivers/Cache/Sqlite.php

   1 <?php defined('SYSPATH') OR die('No direct access allowed.');
   2 /**
   3  * SQLite-based Cache driver.
   4  *
   5  * $Id: Sqlite.php 3917 2009-01-21 03:06:22Z zombor $
   6  *
   7  * @package    Cache
   8  * @author     Kohana Team
   9  * @copyright  (c) 2007-2008 Kohana Team
  10  * @license    http://kohanaphp.com/license.html
  11  */
  12 class Cache_Sqlite_Driver implements Cache_Driver {
  13
  14         // SQLite database instance
  15         protected $db;
  16
  17         // Database error messages
  18         protected $error;
  19
  20         /**
  21          * Logs an SQLite error.
  22          */
  23         protected static function log_error($code)
  24         {
  25                 // Log an error
  26                 Kohana::log('error', 'Cache: SQLite error: '.sqlite_error_string($error));
  27         }
  28
  29         /**
  30          * Tests that the storage location is a directory and is writable.
  31          */
  32         public function __construct($filename)
  33         {
  34                 // Get the directory name
  35                 $directory = str_replace('\\', '/', realpath(pathinfo($filename, PATHINFO_DIRNAME))).'/';
  36
  37                 // Set the filename from the real directory path
  38                 $filename = $directory.basename($filename);
  39
  40                 // Make sure the cache directory is writable
  41                 if ( ! is_dir($directory) OR ! is_writable($directory))
  42                         throw new Kohana_Exception('cache.unwritable', $directory);
  43
  44                 // Make sure the cache database is writable
  45                 if (is_file($filename) AND ! is_writable($filename))
  46                         throw new Kohana_Exception('cache.unwritable', $filename);
  47
  48                 // Open up an instance of the database
  49                 $this->db = new SQLiteDatabase($filename, '0666', $error);
  50
  51                 // Throw an exception if there's an error
  52                 if ( ! empty($error))
  53                         throw new Kohana_Exception('cache.driver_error', sqlite_error_string($error));
  54
  55                 $query  = "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'caches'";
  56                 $tables = $this->db->query($query, SQLITE_BOTH, $error);
  57
  58                 // Throw an exception if there's an error
  59                 if ( ! empty($error))
  60                         throw new Kohana_Exception('cache.driver_error', sqlite_error_string($error));
  61
  62                 if ($tables->numRows() == 0)
  63                 {
  64                         Kohana::log('error', 'Cache: Initializing new SQLite cache database');
  65
  66                         // Issue a CREATE TABLE command
  67                         $this->db->unbufferedQuery(Kohana::config('cache_sqlite.schema'));
  68                 }
  69         }
  70
  71         /**
  72          * Checks if a cache id is already set.
  73          *
  74          * @param  string   cache id
  75          * @return boolean
  76          */
  77         public function exists($id)
  78         {
  79                 // Find the id that matches
  80                 $query = "SELECT id FROM caches WHERE id = '$id'";
  81
  82                 return ($this->db->query($query)->numRows() > 0);
  83         }
  84
  85         /**
  86          * Sets a cache item to the given data, tags, and lifetime.
  87          *
  88          * @param   string   cache id to set
  89          * @param   string   data in the cache
  90          * @param   array    cache tags
  91          * @param   integer  lifetime
  92          * @return  bool
  93          */
  94         public function set($id, $data, $tags, $lifetime)
  95         {
  96                 // Find the data hash
  97                 $hash = sha1($data);
  98
  99                 // Escape the data
 100                 $data = sqlite_escape_string($data);
 101
 102                 // Escape the tags
 103                 $tags = sqlite_escape_string(implode(',', $tags));
 104
 105                 // Cache Sqlite driver expects unix timestamp
 106                 if ($lifetime !== 0)
 107                 {
 108                         $lifetime += time();
 109                 }
 110
 111                 $query = $this->exists($id)
 112                         ? "UPDATE caches SET hash = '$hash', tags = '$tags', expiration = '$lifetime', cache = '$data' WHERE id = '$id'"
 113                         : "INSERT INTO caches VALUES('$id', '$hash', '$tags', '$lifetime', '$data')";
 114
 115                 // Run the query
 116                 $this->db->unbufferedQuery($query, SQLITE_BOTH, $error);
 117
 118                 empty($error) or self::log_error($error);
 119
 120                 return empty($error);
 121         }
 122
 123         /**
 124          * Finds an array of ids for a given tag.
 125          *
 126          * @param  string  tag name
 127          * @return array   of ids that match the tag
 128          */
 129         public function find($tag)
 130         {
 131                 $query = "SELECT id FROM caches WHERE tags LIKE '%{$tag}%'";
 132                 $query = $this->db->query($query, SQLITE_BOTH, $error);
 133
 134                 empty($error) or self::log_error($error);
 135
 136                 if (empty($error) AND $query->numRows() > 0)
 137                 {
 138                         $array = array();
 139                         while ($row = $query->fetchObject())
 140                         {
 141                                 // Add each id to the array
 142                                 $array[] = $row->id;
 143                         }
 144                         return $array;
 145                 }
 146
 147                 return FALSE;
 148         }
 149
 150         /**
 151          * Fetches a cache item. This will delete the item if it is expired or if
 152          * the hash does not match the stored hash.
 153          *
 154          * @param  string  cache id
 155          * @return mixed|NULL
 156          */
 157         public function get($id)
 158         {
 159                 $query = "SELECT id, hash, expiration, cache FROM caches WHERE id = '{$id}' LIMIT 0, 1";
 160                 $query = $this->db->query($query, SQLITE_BOTH, $error);
 161
 162                 empty($error) or self::log_error($error);
 163
 164                 if (empty($error) AND $cache = $query->fetchObject())
 165                 {
 166                         // Make sure the expiration is valid and that the hash matches
 167                         if (($cache->expiration != 0 AND $cache->expiration <= time()) OR $cache->hash !== sha1($cache->cache))
 168                         {
 169                                 // Cache is not valid, delete it now
 170                                 $this->delete($cache->id);
 171                         }
 172                         else
 173                         {
 174                                 // Return the valid cache data
 175                                 return $cache->cache;
 176                         }
 177                 }
 178
 179                 // No valid cache found
 180                 return NULL;
 181         }
 182
 183         /**
 184          * Deletes a cache item by id or tag
 185          *
 186          * @param  string  cache id or tag, or TRUE for "all items"
 187          * @param  bool    use tags
 188          * @return bool
 189          */
 190         public function delete($id, $tag = FALSE)
 191         {
 192                 if ($id === TRUE)
 193                 {
 194                         // Delete all caches
 195                         $where = '1';
 196                 }
 197                 elseif ($tag == FALSE)
 198                 {
 199                         // Delete by id
 200                         $where = "id = '{$id}'";
 201                 }
 202                 else
 203                 {
 204                         // Delete by tag
 205                         $where = "tags LIKE '%{$tag}%'";
 206                 }
 207
 208                 $this->db->unbufferedQuery('DELETE FROM caches WHERE '.$where, SQLITE_BOTH, $error);
 209
 210                 empty($error) or self::log_error($error);
 211
 212                 return empty($error);
 213         }
 214
 215         /**
 216          * Deletes all cache files that are older than the current time.
 217          */
 218         public function delete_expired()
 219         {
 220                 // Delete all expired caches
 221                 $query = 'DELETE FROM caches WHERE expiration != 0 AND expiration <= '.time();
 222
 223                 $this->db->unbufferedQuery($query);
 224
 225                 return TRUE;
 226         }
 227
 228 } // End Cache SQLite Driver