Implements: Kohana_Cache_GarbageCollect | Cache_GarbageCollect | Kohana_Cache_Tagging | Cache_Tagging
Kohana Cache Sqlite Driver
Requires SQLite3 and PDO
Class declared in MODPATH/cache/classes/Cache/Sqlite.php on line 3.
integer 3600
string
$defaultlink to thisdefault driver to use
string(4) "file"
Kohana_Cache
$instanceslink to thisinstances
array(0)
Config
$_configlink to thisarray(0)
PDO
$_dblink to thisDatabase resource
NULL
Delete a cache entry based on id
string
$id
required - Id boolean
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();
}
Delete all cache entries
boolean
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();
}
Delete cache entries based on a tag
string
$tag
required - Tag boolean
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();
}
Find cache entries based on a tag
string
$tag
required - Tag array
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
;
}
Garbage collection method that cleans any expired cache entries from the cache.
void
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()]);
}
}
Retrieve a value based on an id
string
$id
required - Id string
$default
= NULL - Default [Optional] Default value to return if id not found mixed
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
;
}
}
Set a value based on an id. Optionally add tags.
string
$id
required - Id mixed
$data
required - Data integer
$lifetime
= NULL - Lifetime [Optional] boolean
public
function
set(
$id
,
$data
,
$lifetime
= null)
{
return
(bool)
$this
->set_with_tags(
$id
,
$data
,
$lifetime
);
}
Set a value based on an id. Optionally add tags.
string
$id
required - Id mixed
$data
required - Data integer
$lifetime
= NULL - Lifetime [Optional] array
$tags
= NULL - Tags [Optional] boolean
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();
}
Overload the __clone() method to prevent cloning
void
final
public
function
__clone()
{
throw
new
Cache_Exception(
'Cloning of Kohana_Cache objects is forbidden'
);
}
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([
'driver'
=>
'memcache'
,
'...'
]);
// Set a new configuration setting
$cache
->config(
'servers'
, [
'foo'
=>
'bar'
,
'...'
]);
// Get a configuration setting
$servers
=
$cache
->config('servers);
mixed
$key
= NULL - Key to set to array, either array or config path mixed
$value
= NULL - Value to associate with key mixed
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
;
}
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'
];
string
$group
= NULL - The name of the cache group to use [Optional] Cache
public
static
function
instance(
$group
= null)
{
// 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
];
}
Sets up the PDO SQLite table and initialises the PDO connection
array
$config
required - Configuration
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()]);
}
}
}
Tests whether an id exists or not
string
$id
required - Id boolean
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();
}
Replaces troublesome characters with underscores.
// Sanitize a cache id
$id
=
$this
->_sanitize_id(
$id
);
string
$id
required - Id of cache to sanitize string
protected
function
_sanitize_id(
$id
)
{
// Change slashes and spaces to underscores
return
str_replace
([
'/'
,
'\\'
,
' '
],
'_'
,
$id
);
}