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 thisPDO
$_dblink to thisDatabase resource
Delete a cache entry based on id
string
$id
required - Idboolean
public
function
delete
(
$id
)
{
// Prepare statement
$statement
=
$this
->_db->prepare(
'DELETE FROM caches WHERE id = :id'
);
// Remove the entry
try
{
$statement
->execute(
array
(
':id'
=>
$this
->_sanitize_id(
$id
)));
}
catch
(PDOException
$e
)
{
throw
new
Cache_Exception(
'There was a problem querying the local SQLite3 cache. :error'
,
array
(
':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'
,
array
(
':error'
=>
$e
->getMessage()));
}
return
(bool)
$statement
->rowCount();
}
Delete cache entries based on a tag
string
$tag
required - Tagboolean
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(
array
(
':tag'
=>
"%<{$tag}>%"
));
}
catch
(PDOException
$e
)
{
throw
new
Cache_Exception(
'There was a problem querying the local SQLite3 cache. :error'
,
array
(
':error'
=>
$e
->getMessage()));
}
return
(bool)
$statement
->rowCount();
}
Find cache entries based on a tag
string
$tag
required - Tagarray
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(
array
(
':tag'
=>
"%<{$tag}>%"
)))
{
return
array
();
}
}
catch
(PDOException
$e
)
{
throw
new
Cache_Exception(
'There was a problem querying the local SQLite3 cache. :error'
,
array
(
':error'
=>
$e
->getMessage()));
}
$result
=
array
();
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(
array
(
':expiration'
=> time()));
}
catch
(PDOException
$e
)
{
throw
new
Cache_Exception(
'There was a problem querying the local SQLite3 cache. :error'
,
array
(
':error'
=>
$e
->getMessage()));
}
}
Retrieve a value based on an id
string
$id
required - Idstring
$default
= NULL - Default [Optional] Default value to return if id not foundmixed
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(
array
(
':id'
=>
$this
->_sanitize_id(
$id
)));
}
catch
(PDOException
$e
)
{
throw
new
Cache_Exception(
'There was a problem querying the local SQLite3 cache. :error'
,
array
(
':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 - Idmixed
$data
required - Datainteger
$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 - Idmixed
$data
required - Datainteger
$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(
array
(
':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'
,
array
(
':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(
array
(
'driver'
=>
'memcache'
,
'...'
));
// Set a new configuration setting
$cache
->config(
'servers'
,
array
(
'foo'
=>
'bar'
,
'...'
));
// Get a configuration setting
$servers
=
$cache
->config('servers);
mixed
$key
= NULL - Key to set to array, either array or config pathmixed
$value
= NULL - Value to associate with keymixed
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'
,
array
(
':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'
,
array
(
':error'
=>
$e
->getMessage()));
}
}
}
Tests whether an id exists or not
string
$id
required - Idboolean
protected
function
exists(
$id
)
{
$statement
=
$this
->_db->prepare(
'SELECT id FROM caches WHERE id = :id'
);
try
{
$statement
->execute(
array
(
':id'
=>
$this
->_sanitize_id(
$id
)));
}
catch
(PDOExeption
$e
)
{
throw
new
Cache_Exception(
'There was a problem querying the local SQLite3 cache. :error'
,
array
(
':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 sanitizestring
protected
function
_sanitize_id(
$id
)
{
// Change slashes and spaces to underscores
return
str_replace
(
array
(
'/'
,
'\\'
,
' '
),
'_'
,
$id
);
}