Cache_Sqlite
extends Kohana_Cache_Sqlite
extends Cache
extends Kohana_Cache
Implements: Kohana_Cache_GarbageCollect | Cache_GarbageCollect | Kohana_Cache_Tagging | Cache_Tagging
Kohana Cache Sqlite Driver
Requires SQLite3 and PDO
Information
This class is a transparent base class for Kohana_Cache_Sqlite
Constants
Properties
Constants
-
DEFAULT_EXPIRE
integer 3600
Properties
-
public static string $default
-
default driver to use
-
string(4) "file" -
public static Kohana_Cache $instances
-
instances
-
array(0) -
protected Config $_config
-
Default value:
array(0) -
protected PDO $_db
-
Database resource
-
Default value:
NULL
Methods
public delete(string $id ) (defined in Kohana_Cache_Sqlite)
Delete a cache entry based on id
Parameters
- string $id required - Id
Tags
Return Values
- boolean
Source Code
public function delete($id)
{
// Prepare statement
$statement = $this->_db->prepare('DELETE FROM caches WHERE id = :id');
// Remove the entry
try
{
$statement->execute([':id' => $this->_sanitize_id($id)]);
}
catch (PDOException $e)
{
throw new Cache_Exception('There was a problem querying the local SQLite3 cache. :error', [':error' => $e->getMessage()]);
}
return (bool) $statement->rowCount();
}
public delete_all() (defined in Kohana_Cache_Sqlite)
Delete all cache entries
Return Values
- boolean
Source Code
public function delete_all()
{
// Prepare statement
$statement = $this->_db->prepare('DELETE FROM caches');
// Remove the entry
try
{
$statement->execute();
}
catch (PDOException $e)
{
throw new Cache_Exception('There was a problem querying the local SQLite3 cache. :error', [':error' => $e->getMessage()]);
}
return (bool) $statement->rowCount();
}
public delete_tag(string $tag ) (defined in Kohana_Cache_Sqlite)
Delete cache entries based on a tag
Parameters
- string $tag required - Tag
Tags
Return Values
- boolean
Source Code
public function delete_tag($tag)
{
// Prepare the statement
$statement = $this->_db->prepare('DELETE FROM caches WHERE tags LIKE :tag');
// Try to delete
try
{
$statement->execute([':tag' => "%<{$tag}>%"]);
}
catch (PDOException $e)
{
throw new Cache_Exception('There was a problem querying the local SQLite3 cache. :error', [':error' => $e->getMessage()]);
}
return (bool) $statement->rowCount();
}
public find(string $tag ) (defined in Kohana_Cache_Sqlite)
Find cache entries based on a tag
Parameters
- string $tag required - Tag
Tags
Return Values
- array
Source Code
public function find($tag)
{
// Prepare the statement
$statement = $this->_db->prepare('SELECT id, cache FROM caches WHERE tags LIKE :tag');
// Try to find
try
{
if ( ! $statement->execute([':tag' => "%<{$tag}>%"]))
{
return [];
}
}
catch (PDOException $e)
{
throw new Cache_Exception('There was a problem querying the local SQLite3 cache. :error', [':error' => $e->getMessage()]);
}
$result = [];
while ($row = $statement->fetchObject())
{
// Disable notices for unserializing
$ER = error_reporting(~E_NOTICE);
$result[$row->id] = unserialize($row->cache);
// Turn notices back on
error_reporting($ER);
}
return $result;
}
public garbage_collect() (defined in Kohana_Cache_Sqlite)
Garbage collection method that cleans any expired cache entries from the cache.
Return Values
- void
Source Code
public function garbage_collect()
{
// Create the sequel statement
$statement = $this->_db->prepare('DELETE FROM caches WHERE expiration < :expiration');
try
{
$statement->execute([':expiration' => time()]);
}
catch (PDOException $e)
{
throw new Cache_Exception('There was a problem querying the local SQLite3 cache. :error', [':error' => $e->getMessage()]);
}
}
public get(string $id [, string $default = NULL ] ) (defined in Kohana_Cache_Sqlite)
Retrieve a value based on an id
Parameters
- string $id required - Id
- string $default = NULL - Default [Optional] Default value to return if id not found
Tags
Return Values
- mixed
Source Code
public function get($id, $default = NULL)
{
// Prepare statement
$statement = $this->_db->prepare('SELECT id, expiration, cache FROM caches WHERE id = :id LIMIT 0, 1');
// Try and load the cache based on id
try
{
$statement->execute([':id' => $this->_sanitize_id($id)]);
}
catch (PDOException $e)
{
throw new Cache_Exception('There was a problem querying the local SQLite3 cache. :error', [':error' => $e->getMessage()]);
}
if ( ! $result = $statement->fetch(PDO::FETCH_OBJ))
{
return $default;
}
// If the cache has expired
if ($result->expiration != 0 and $result->expiration <= time())
{
// Delete it and return default value
$this->delete($id);
return $default;
}
// Otherwise return cached object
else
{
// Disable notices for unserializing
$ER = error_reporting(~E_NOTICE);
// Return the valid cache data
$data = unserialize($result->cache);
// Turn notices back on
error_reporting($ER);
// Return the resulting data
return $data;
}
}
public set(string $id , mixed $data [, integer $lifetime = NULL ] ) (defined in Kohana_Cache_Sqlite)
Set a value based on an id. Optionally add tags.
Parameters
- string $id required - Id
- mixed $data required - Data
- integer $lifetime = NULL - Lifetime [Optional]
Return Values
- boolean
Source Code
public function set($id, $data, $lifetime = NULL)
{
return (bool) $this->set_with_tags($id, $data, $lifetime);
}
public set_with_tags(string $id , mixed $data [, integer $lifetime = NULL , array $tags = NULL ] ) (defined in Kohana_Cache_Sqlite)
Set a value based on an id. Optionally add tags.
Parameters
- string $id required - Id
- mixed $data required - Data
- integer $lifetime = NULL - Lifetime [Optional]
- array $tags = NULL - Tags [Optional]
Tags
Return Values
- boolean
Source Code
public function set_with_tags($id, $data, $lifetime = NULL, array $tags = NULL)
{
// Serialize the data
$data = serialize($data);
// Normalise tags
$tags = (NULL === $tags) ? NULL : ('<'.implode('>,<', $tags).'>');
// Setup lifetime
if ($lifetime === NULL)
{
$lifetime = (0 === Arr::get($this->_config, 'default_expire', NULL)) ? 0 : (Arr::get($this->_config, 'default_expire', Cache::DEFAULT_EXPIRE) + time());
}
else
{
$lifetime = (0 === $lifetime) ? 0 : ($lifetime + time());
}
// Prepare statement
// $this->exists() may throw Cache_Exception, no need to catch/rethrow
$statement = $this->exists($id) ? $this->_db->prepare('UPDATE caches SET expiration = :expiration, cache = :cache, tags = :tags WHERE id = :id') : $this->_db->prepare('INSERT INTO caches (id, cache, expiration, tags) VALUES (:id, :cache, :expiration, :tags)');
// Try to insert
try
{
$statement->execute([':id' => $this->_sanitize_id($id), ':cache' => $data, ':expiration' => $lifetime, ':tags' => $tags]);
}
catch (PDOException $e)
{
throw new Cache_Exception('There was a problem querying the local SQLite3 cache. :error', [':error' => $e->getMessage()]);
}
return (bool) $statement->rowCount();
}
final public __clone() (defined in Kohana_Cache)
Overload the __clone() method to prevent cloning
Tags
Return Values
- void
Source Code
final public function __clone()
{
throw new Cache_Exception('Cloning of Kohana_Cache objects is forbidden');
}
public config([ mixed $key = NULL , mixed $value = NULL ] ) (defined in Kohana_Cache)
Getter and setter for the configuration. If no argument provided, the current configuration is returned. Otherwise the configuration is set to this class.
// Overwrite all configuration
$cache->config(array('driver' => 'memcache', '...'));
// Set a new configuration setting
$cache->config('servers', array(
'foo' => 'bar',
'...'
));
// Get a configuration setting
$servers = $cache->config('servers);
Parameters
- mixed $key = NULL - Key to set to array, either array or config path
- mixed $value = NULL - Value to associate with key
Return Values
- mixed
Source Code
public function config($key = NULL, $value = NULL)
{
if ($key === NULL)
return $this->_config;
if (is_array($key))
{
$this->_config = $key;
}
else
{
if ($value === NULL)
return Arr::get($this->_config, $key);
$this->_config[$key] = $value;
}
return $this;
}
public static instance([ string $group = NULL ] ) (defined in Kohana_Cache)
Creates a singleton of a Kohana Cache group. If no group is supplied the default cache group is used.
// Create an instance of the default group
$default_group = Cache::instance();
// Create an instance of a group
$foo_group = Cache::instance('foo');
// Access an instantiated group directly
$foo_group = Cache::$instances['default'];
Parameters
- string $group = NULL - The name of the cache group to use [Optional]
Tags
Return Values
- Cache
Source Code
public static function instance($group = NULL)
{
// If there is no group supplied, try to get it from the config
if ($group === NULL)
{
$group = Kohana::$config->load('cache.default');
}
// If there is no group supplied
if ($group === NULL)
{
// Use the default setting
$group = Cache::$default;
}
if (isset(Cache::$instances[$group]))
{
// Return the current group if initiated already
return Cache::$instances[$group];
}
$config = Kohana::$config->load('cache');
if ( ! $config->offsetExists($group))
{
throw new Cache_Exception(
'Failed to load Kohana Cache group: :group',
[':group' => $group]
);
}
$config = $config->get($group);
// Create a new cache type instance
$cache_class = 'Cache_'.ucfirst($config['driver']);
Cache::$instances[$group] = new $cache_class($config);
// Return the instance
return Cache::$instances[$group];
}
protected __construct(array $config ) (defined in Kohana_Cache_Sqlite)
Sets up the PDO SQLite table and initialises the PDO connection
Parameters
- array $config required - Configuration
Tags
Source Code
protected function __construct(array $config)
{
parent::__construct($config);
$database = Arr::get($this->_config, 'database', NULL);
if ($database === NULL)
{
throw new Cache_Exception('Database path not available in Kohana Cache configuration');
}
// Load new Sqlite DB
$this->_db = new PDO('sqlite:'.$database);
// Test for existing DB
$result = $this->_db->query("SELECT * FROM sqlite_master WHERE name = 'caches' AND type = 'table'")->fetchAll();
// If there is no table, create a new one
if (0 == count($result))
{
$database_schema = Arr::get($this->_config, 'schema', NULL);
if ($database_schema === NULL)
{
throw new Cache_Exception('Database schema not found in Kohana Cache configuration');
}
try
{
// Create the caches table
$this->_db->query(Arr::get($this->_config, 'schema', NULL));
}
catch (PDOException $e)
{
throw new Cache_Exception('Failed to create new SQLite caches table with the following error : :error', [':error' => $e->getMessage()]);
}
}
}
protected exists(string $id ) (defined in Kohana_Cache_Sqlite)
Tests whether an id exists or not
Parameters
- string $id required - Id
Tags
Return Values
- boolean
Source Code
protected function exists($id)
{
$statement = $this->_db->prepare('SELECT id FROM caches WHERE id = :id');
try
{
$statement->execute([':id' => $this->_sanitize_id($id)]);
}
catch (PDOExeption $e)
{
throw new Cache_Exception('There was a problem querying the local SQLite3 cache. :error', [':error' => $e->getMessage()]);
}
return (bool) $statement->fetchAll();
}
protected _sanitize_id(string $id ) (defined in Kohana_Cache)
Replaces troublesome characters with underscores and adds prefix to avoid duplicates
// Sanitize a cache id
$id = $this->_sanitize_id($id);
Parameters
- string $id required - Id of cache to sanitize
Return Values
- string
Source Code
protected function _sanitize_id($id)
{
// adding cache prefix to avoid duplicates
$prefix = '';
// configuration for the specific cache group
if (isset($this->_config['prefix']) AND $this->_config['prefix'] !== NULL)
{
$prefix = $this->_config['prefix'];
}
// prefix general configuration cache
else
{
$prefix = Kohana::$config->load('cache.prefix');
}
// sha1 the id makes sure name is not too long and has not any not allowed characters
return $prefix.sha1($id);
}
