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