PluginProbe
Visualizer – Tables & Charts Manager with Built-in AI Generator / 3.0.3
Visualizer – Tables & Charts Manager with Built-in AI Generator v3.0.3
4.0.8 4.0.7 4.0.6 4.0.5 4.0.4 4.0.3 3.0.5 3.0.6 3.0.7 3.0.8 3.0.9 3.1.0 3.1.1 3.1.2 3.1.3 3.10.0 3.10.1 3.10.10 3.10.11 3.10.12 3.10.13 3.10.14 3.10.15 3.10.2 3.10.3 All 149 releases
← All changes | vendor/phpoffice/phpexcel/Classes/PHPExcel/CachedObjectStorage/SQLite3.php +345 -346 3.1.1 → 3.0.3 View file →
@@ -1,346 +1,345 @@
1 -<?php
2 -
3 -/**
4 - * PHPExcel_CachedObjectStorage_SQLite3
5 - *
6 - * Copyright (c) 2006 - 2015 PHPExcel
7 - *
8 - * This library is free software; you can redistribute it and/or
9 - * modify it under the terms of the GNU Lesser General Public
10 - * License as published by the Free Software Foundation; either
11 - * version 2.1 of the License, or (at your option) any later version.
12 - *
13 - * This library is distributed in the hope that it will be useful,
14 - * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 - * Lesser General Public License for more details.
17 - *
18 - * You should have received a copy of the GNU Lesser General Public
19 - * License along with this library; if not, write to the Free Software
20 - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 - *
22 - * @category PHPExcel
23 - * @package PHPExcel_CachedObjectStorage
24 - * @copyright Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
25 - * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
26 - * @version ##VERSION##, ##DATE##
27 - */
28 -class PHPExcel_CachedObjectStorage_SQLite3 extends PHPExcel_CachedObjectStorage_CacheBase implements PHPExcel_CachedObjectStorage_ICache
29 -{
30 - /**
31 - * Database table name
32 - *
33 - * @var string
34 - */
35 - private $TableName = null;
36 -
37 - /**
38 - * Database handle
39 - *
40 - * @var resource
41 - */
42 - private $DBHandle = null;
43 -
44 - /**
45 - * Prepared statement for a SQLite3 select query
46 - *
47 - * @var SQLite3Stmt
48 - */
49 - private $selectQuery;
50 -
51 - /**
52 - * Prepared statement for a SQLite3 insert query
53 - *
54 - * @var SQLite3Stmt
55 - */
56 - private $insertQuery;
57 -
58 - /**
59 - * Prepared statement for a SQLite3 update query
60 - *
61 - * @var SQLite3Stmt
62 - */
63 - private $updateQuery;
64 -
65 - /**
66 - * Prepared statement for a SQLite3 delete query
67 - *
68 - * @var SQLite3Stmt
69 - */
70 - private $deleteQuery;
71 -
72 - /**
73 - * Store cell data in cache for the current cell object if it's "dirty",
74 - * and the 'nullify' the current cell object
75 - *
76 - * @return void
77 - * @throws PHPExcel_Exception
78 - */
79 - protected function storeData()
80 - {
81 - if ($this->currentCellIsDirty && !empty($this->currentObjectID)) {
82 - $this->currentObject->detach();
83 -
84 - $this->insertQuery->bindValue('id', $this->currentObjectID, SQLITE3_TEXT);
85 - $this->insertQuery->bindValue('data', serialize($this->currentObject), SQLITE3_BLOB);
86 - $result = $this->insertQuery->execute();
87 - if ($result === false) {
88 - throw new PHPExcel_Exception($this->DBHandle->lastErrorMsg());
89 - }
90 - $this->currentCellIsDirty = false;
91 - }
92 - $this->currentObjectID = $this->currentObject = null;
93 - }
94 -
95 - /**
96 - * Add or Update a cell in cache identified by coordinate address
97 - *
98 - * @param string $pCoord Coordinate address of the cell to update
99 - * @param PHPExcel_Cell $cell Cell to update
100 - * @return PHPExcel_Cell
101 - * @throws PHPExcel_Exception
102 - */
103 - public function addCacheData($pCoord, PHPExcel_Cell $cell)
104 - {
105 - if (($pCoord !== $this->currentObjectID) && ($this->currentObjectID !== null)) {
106 - $this->storeData();
107 - }
108 -
109 - $this->currentObjectID = $pCoord;
110 - $this->currentObject = $cell;
111 - $this->currentCellIsDirty = true;
112 -
113 - return $cell;
114 - }
115 -
116 - /**
117 - * Get cell at a specific coordinate
118 - *
119 - * @param string $pCoord Coordinate of the cell
120 - * @throws PHPExcel_Exception
121 - * @return PHPExcel_Cell Cell that was found, or null if not found
122 - */
123 - public function getCacheData($pCoord)
124 - {
125 - if ($pCoord === $this->currentObjectID) {
126 - return $this->currentObject;
127 - }
128 - $this->storeData();
129 -
130 - $this->selectQuery->bindValue('id', $pCoord, SQLITE3_TEXT);
131 - $cellResult = $this->selectQuery->execute();
132 - if ($cellResult === false) {
133 - throw new PHPExcel_Exception($this->DBHandle->lastErrorMsg());
134 - }
135 - $cellData = $cellResult->fetchArray(SQLITE3_ASSOC);
136 - if ($cellData === false) {
137 - // Return null if requested entry doesn't exist in cache
138 - return null;
139 - }
140 -
141 - // Set current entry to the requested entry
142 - $this->currentObjectID = $pCoord;
143 -
144 - $this->currentObject = unserialize($cellData['value']);
145 - // Re-attach this as the cell's parent
146 - $this->currentObject->attach($this);
147 -
148 - // Return requested entry
149 - return $this->currentObject;
150 - }
151 -
152 - /**
153 - * Is a value set for an indexed cell?
154 - *
155 - * @param string $pCoord Coordinate address of the cell to check
156 - * @return boolean
157 - */
158 - public function isDataSet($pCoord)
159 - {
160 - if ($pCoord === $this->currentObjectID) {
161 - return true;
162 - }
163 -
164 - // Check if the requested entry exists in the cache
165 - $this->selectQuery->bindValue('id', $pCoord, SQLITE3_TEXT);
166 - $cellResult = $this->selectQuery->execute();
167 - if ($cellResult === false) {
168 - throw new PHPExcel_Exception($this->DBHandle->lastErrorMsg());
169 - }
170 - $cellData = $cellResult->fetchArray(SQLITE3_ASSOC);
171 -
172 - return ($cellData === false) ? false : true;
173 - }
174 -
175 - /**
176 - * Delete a cell in cache identified by coordinate address
177 - *
178 - * @param string $pCoord Coordinate address of the cell to delete
179 - * @throws PHPExcel_Exception
180 - */
181 - public function deleteCacheData($pCoord)
182 - {
183 - if ($pCoord === $this->currentObjectID) {
184 - $this->currentObject->detach();
185 - $this->currentObjectID = $this->currentObject = null;
186 - }
187 -
188 - // Check if the requested entry exists in the cache
189 - $this->deleteQuery->bindValue('id', $pCoord, SQLITE3_TEXT);
190 - $result = $this->deleteQuery->execute();
191 - if ($result === false) {
192 - throw new PHPExcel_Exception($this->DBHandle->lastErrorMsg());
193 - }
194 -
195 - $this->currentCellIsDirty = false;
196 - }
197 -
198 - /**
199 - * Move a cell object from one address to another
200 - *
201 - * @param string $fromAddress Current address of the cell to move
202 - * @param string $toAddress Destination address of the cell to move
203 - * @return boolean
204 - */
205 - public function moveCell($fromAddress, $toAddress)
206 - {
207 - if ($fromAddress === $this->currentObjectID) {
208 - $this->currentObjectID = $toAddress;
209 - }
210 -
211 - $this->deleteQuery->bindValue('id', $toAddress, SQLITE3_TEXT);
212 - $result = $this->deleteQuery->execute();
213 - if ($result === false) {
214 - throw new PHPExcel_Exception($this->DBHandle->lastErrorMsg());
215 - }
216 -
217 - $this->updateQuery->bindValue('toid', $toAddress, SQLITE3_TEXT);
218 - $this->updateQuery->bindValue('fromid', $fromAddress, SQLITE3_TEXT);
219 - $result = $this->updateQuery->execute();
220 - if ($result === false) {
221 - throw new PHPExcel_Exception($this->DBHandle->lastErrorMsg());
222 - }
223 -
224 - return true;
225 - }
226 -
227 - /**
228 - * Get a list of all cell addresses currently held in cache
229 - *
230 - * @return string[]
231 - */
232 - public function getCellList()
233 - {
234 - if ($this->currentObjectID !== null) {
235 - $this->storeData();
236 - }
237 -
238 - $query = "SELECT id FROM kvp_".$this->TableName;
239 - $cellIdsResult = $this->DBHandle->query($query);
240 - if ($cellIdsResult === false) {
241 - throw new PHPExcel_Exception($this->DBHandle->lastErrorMsg());
242 - }
243 -
244 - $cellKeys = array();
245 - while ($row = $cellIdsResult->fetchArray(SQLITE3_ASSOC)) {
246 - $cellKeys[] = $row['id'];
247 - }
248 -
249 - return $cellKeys;
250 - }
251 -
252 - /**
253 - * Clone the cell collection
254 - *
255 - * @param PHPExcel_Worksheet $parent The new worksheet
256 - * @return void
257 - */
258 - public function copyCellCollection(PHPExcel_Worksheet $parent)
259 - {
260 - $this->currentCellIsDirty;
261 - $this->storeData();
262 -
263 - // Get a new id for the new table name
264 - $tableName = str_replace('.', '_', $this->getUniqueID());
265 - if (!$this->DBHandle->exec('CREATE TABLE kvp_'.$tableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)
266 - AS SELECT * FROM kvp_'.$this->TableName)
267 - ) {
268 - throw new PHPExcel_Exception($this->DBHandle->lastErrorMsg());
269 - }
270 -
271 - // Copy the existing cell cache file
272 - $this->TableName = $tableName;
273 - }
274 -
275 - /**
276 - * Clear the cell collection and disconnect from our parent
277 - *
278 - * @return void
279 - */
280 - public function unsetWorksheetCells()
281 - {
282 - if (!is_null($this->currentObject)) {
283 - $this->currentObject->detach();
284 - $this->currentObject = $this->currentObjectID = null;
285 - }
286 - // detach ourself from the worksheet, so that it can then delete this object successfully
287 - $this->parent = null;
288 -
289 - // Close down the temporary cache file
290 - $this->__destruct();
291 - }
292 -
293 - /**
294 - * Initialise this new cell collection
295 - *
296 - * @param PHPExcel_Worksheet $parent The worksheet for this cell collection
297 - */
298 - public function __construct(PHPExcel_Worksheet $parent)
299 - {
300 - parent::__construct($parent);
301 - if (is_null($this->DBHandle)) {
302 - $this->TableName = str_replace('.', '_', $this->getUniqueID());
303 - $_DBName = ':memory:';
304 -
305 - $this->DBHandle = new SQLite3($_DBName);
306 - if ($this->DBHandle === false) {
307 - throw new PHPExcel_Exception($this->DBHandle->lastErrorMsg());
308 - }
309 - if (!$this->DBHandle->exec('CREATE TABLE kvp_'.$this->TableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)')) {
310 - throw new PHPExcel_Exception($this->DBHandle->lastErrorMsg());
311 - }
312 - }
313 -
314 - $this->selectQuery = $this->DBHandle->prepare("SELECT value FROM kvp_".$this->TableName." WHERE id = :id");
315 - $this->insertQuery = $this->DBHandle->prepare("INSERT OR REPLACE INTO kvp_".$this->TableName." VALUES(:id,:data)");
316 - $this->updateQuery = $this->DBHandle->prepare("UPDATE kvp_".$this->TableName." SET id=:toId WHERE id=:fromId");
317 - $this->deleteQuery = $this->DBHandle->prepare("DELETE FROM kvp_".$this->TableName." WHERE id = :id");
318 - }
319 -
320 - /**
321 - * Destroy this cell collection
322 - */
323 - public function __destruct()
324 - {
325 - if (!is_null($this->DBHandle)) {
326 - $this->DBHandle->exec('DROP TABLE kvp_'.$this->TableName);
327 - $this->DBHandle->close();
328 - }
329 - $this->DBHandle = null;
330 - }
331 -
332 - /**
333 - * Identify whether the caching method is currently available
334 - * Some methods are dependent on the availability of certain extensions being enabled in the PHP build
335 - *
336 - * @return boolean
337 - */
338 - public static function cacheMethodIsAvailable()
339 - {
340 - if (!class_exists('SQLite3', false)) {
341 - return false;
342 - }
343 -
344 - return true;
345 - }
346 -}
1 +<?php
2 +/**
3 + * PHPExcel
4 + *
5 + * Copyright (c) 2006 - 2014 PHPExcel
6 + *
7 + * This library is free software; you can redistribute it and/or
8 + * modify it under the terms of the GNU Lesser General Public
9 + * License as published by the Free Software Foundation; either
10 + * version 2.1 of the License, or (at your option) any later version.
11 + *
12 + * This library is distributed in the hope that it will be useful,
13 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 + * Lesser General Public License for more details.
16 + *
17 + * You should have received a copy of the GNU Lesser General Public
18 + * License along with this library; if not, write to the Free Software
19 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 + *
21 + * @category PHPExcel
22 + * @package PHPExcel_CachedObjectStorage
23 + * @copyright Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
24 + * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
25 + * @version ##VERSION##, ##DATE##
26 + */
27 +
28 +
29 +/**
30 + * PHPExcel_CachedObjectStorage_SQLite3
31 + *
32 + * @category PHPExcel
33 + * @package PHPExcel_CachedObjectStorage
34 + * @copyright Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
35 + */
36 +class PHPExcel_CachedObjectStorage_SQLite3 extends PHPExcel_CachedObjectStorage_CacheBase implements PHPExcel_CachedObjectStorage_ICache {
37 +
38 + /**
39 + * Database table name
40 + *
41 + * @var string
42 + */
43 + private $_TableName = null;
44 +
45 + /**
46 + * Database handle
47 + *
48 + * @var resource
49 + */
50 + private $_DBHandle = null;
51 +
52 + /**
53 + * Prepared statement for a SQLite3 select query
54 + *
55 + * @var SQLite3Stmt
56 + */
57 + private $_selectQuery;
58 +
59 + /**
60 + * Prepared statement for a SQLite3 insert query
61 + *
62 + * @var SQLite3Stmt
63 + */
64 + private $_insertQuery;
65 +
66 + /**
67 + * Prepared statement for a SQLite3 update query
68 + *
69 + * @var SQLite3Stmt
70 + */
71 + private $_updateQuery;
72 +
73 + /**
74 + * Prepared statement for a SQLite3 delete query
75 + *
76 + * @var SQLite3Stmt
77 + */
78 + private $_deleteQuery;
79 +
80 + /**
81 + * Store cell data in cache for the current cell object if it's "dirty",
82 + * and the 'nullify' the current cell object
83 + *
84 + * @return void
85 + * @throws PHPExcel_Exception
86 + */
87 + protected function _storeData() {
88 + if ($this->_currentCellIsDirty && !empty($this->_currentObjectID)) {
89 + $this->_currentObject->detach();
90 +
91 + $this->_insertQuery->bindValue('id',$this->_currentObjectID,SQLITE3_TEXT);
92 + $this->_insertQuery->bindValue('data',serialize($this->_currentObject),SQLITE3_BLOB);
93 + $result = $this->_insertQuery->execute();
94 + if ($result === false)
95 + throw new PHPExcel_Exception($this->_DBHandle->lastErrorMsg());
96 + $this->_currentCellIsDirty = false;
97 + }
98 + $this->_currentObjectID = $this->_currentObject = null;
99 + } // function _storeData()
100 +
101 +
102 + /**
103 + * Add or Update a cell in cache identified by coordinate address
104 + *
105 + * @param string $pCoord Coordinate address of the cell to update
106 + * @param PHPExcel_Cell $cell Cell to update
107 + * @return PHPExcel_Cell
108 + * @throws PHPExcel_Exception
109 + */
110 + public function addCacheData($pCoord, PHPExcel_Cell $cell) {
111 + if (($pCoord !== $this->_currentObjectID) && ($this->_currentObjectID !== null)) {
112 + $this->_storeData();
113 + }
114 +
115 + $this->_currentObjectID = $pCoord;
116 + $this->_currentObject = $cell;
117 + $this->_currentCellIsDirty = true;
118 +
119 + return $cell;
120 + } // function addCacheData()
121 +
122 +
123 + /**
124 + * Get cell at a specific coordinate
125 + *
126 + * @param string $pCoord Coordinate of the cell
127 + * @throws PHPExcel_Exception
128 + * @return PHPExcel_Cell Cell that was found, or null if not found
129 + */
130 + public function getCacheData($pCoord) {
131 + if ($pCoord === $this->_currentObjectID) {
132 + return $this->_currentObject;
133 + }
134 + $this->_storeData();
135 +
136 + $this->_selectQuery->bindValue('id',$pCoord,SQLITE3_TEXT);
137 + $cellResult = $this->_selectQuery->execute();
138 + if ($cellResult === FALSE) {
139 + throw new PHPExcel_Exception($this->_DBHandle->lastErrorMsg());
140 + }
141 + $cellData = $cellResult->fetchArray(SQLITE3_ASSOC);
142 + if ($cellData === FALSE) {
143 + // Return null if requested entry doesn't exist in cache
144 + return NULL;
145 + }
146 +
147 + // Set current entry to the requested entry
148 + $this->_currentObjectID = $pCoord;
149 +
150 + $this->_currentObject = unserialize($cellData['value']);
151 + // Re-attach this as the cell's parent
152 + $this->_currentObject->attach($this);
153 +
154 + // Return requested entry
155 + return $this->_currentObject;
156 + } // function getCacheData()
157 +
158 +
159 + /**
160 + * Is a value set for an indexed cell?
161 + *
162 + * @param string $pCoord Coordinate address of the cell to check
163 + * @return boolean
164 + */
165 + public function isDataSet($pCoord) {
166 + if ($pCoord === $this->_currentObjectID) {
167 + return TRUE;
168 + }
169 +
170 + // Check if the requested entry exists in the cache
171 + $this->_selectQuery->bindValue('id',$pCoord,SQLITE3_TEXT);
172 + $cellResult = $this->_selectQuery->execute();
173 + if ($cellResult === FALSE) {
174 + throw new PHPExcel_Exception($this->_DBHandle->lastErrorMsg());
175 + }
176 + $cellData = $cellResult->fetchArray(SQLITE3_ASSOC);
177 +
178 + return ($cellData === FALSE) ? FALSE : TRUE;
179 + } // function isDataSet()
180 +
181 +
182 + /**
183 + * Delete a cell in cache identified by coordinate address
184 + *
185 + * @param string $pCoord Coordinate address of the cell to delete
186 + * @throws PHPExcel_Exception
187 + */
188 + public function deleteCacheData($pCoord) {
189 + if ($pCoord === $this->_currentObjectID) {
190 + $this->_currentObject->detach();
191 + $this->_currentObjectID = $this->_currentObject = NULL;
192 + }
193 +
194 + // Check if the requested entry exists in the cache
195 + $this->_deleteQuery->bindValue('id',$pCoord,SQLITE3_TEXT);
196 + $result = $this->_deleteQuery->execute();
197 + if ($result === FALSE)
198 + throw new PHPExcel_Exception($this->_DBHandle->lastErrorMsg());
199 +
200 + $this->_currentCellIsDirty = FALSE;
201 + } // function deleteCacheData()
202 +
203 +
204 + /**
205 + * Move a cell object from one address to another
206 + *
207 + * @param string $fromAddress Current address of the cell to move
208 + * @param string $toAddress Destination address of the cell to move
209 + * @return boolean
210 + */
211 + public function moveCell($fromAddress, $toAddress) {
212 + if ($fromAddress === $this->_currentObjectID) {
213 + $this->_currentObjectID = $toAddress;
214 + }
215 +
216 + $this->_deleteQuery->bindValue('id',$toAddress,SQLITE3_TEXT);
217 + $result = $this->_deleteQuery->execute();
218 + if ($result === false)
219 + throw new PHPExcel_Exception($this->_DBHandle->lastErrorMsg());
220 +
221 + $this->_updateQuery->bindValue('toid',$toAddress,SQLITE3_TEXT);
222 + $this->_updateQuery->bindValue('fromid',$fromAddress,SQLITE3_TEXT);
223 + $result = $this->_updateQuery->execute();
224 + if ($result === false)
225 + throw new PHPExcel_Exception($this->_DBHandle->lastErrorMsg());
226 +
227 + return TRUE;
228 + } // function moveCell()
229 +
230 +
231 + /**
232 + * Get a list of all cell addresses currently held in cache
233 + *
234 + * @return string[]
235 + */
236 + public function getCellList() {
237 + if ($this->_currentObjectID !== null) {
238 + $this->_storeData();
239 + }
240 +
241 + $query = "SELECT id FROM kvp_".$this->_TableName;
242 + $cellIdsResult = $this->_DBHandle->query($query);
243 + if ($cellIdsResult === false)
244 + throw new PHPExcel_Exception($this->_DBHandle->lastErrorMsg());
245 +
246 + $cellKeys = array();
247 + while ($row = $cellIdsResult->fetchArray(SQLITE3_ASSOC)) {
248 + $cellKeys[] = $row['id'];
249 + }
250 +
251 + return $cellKeys;
252 + } // function getCellList()
253 +
254 +
255 + /**
256 + * Clone the cell collection
257 + *
258 + * @param PHPExcel_Worksheet $parent The new worksheet
259 + * @return void
260 + */
261 + public function copyCellCollection(PHPExcel_Worksheet $parent) {
262 + $this->_currentCellIsDirty;
263 + $this->_storeData();
264 +
265 + // Get a new id for the new table name
266 + $tableName = str_replace('.','_',$this->_getUniqueID());
267 + if (!$this->_DBHandle->exec('CREATE TABLE kvp_'.$tableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)
268 + AS SELECT * FROM kvp_'.$this->_TableName))
269 + throw new PHPExcel_Exception($this->_DBHandle->lastErrorMsg());
270 +
271 + // Copy the existing cell cache file
272 + $this->_TableName = $tableName;
273 + } // function copyCellCollection()
274 +
275 +
276 + /**
277 + * Clear the cell collection and disconnect from our parent
278 + *
279 + * @return void
280 + */
281 + public function unsetWorksheetCells() {
282 + if(!is_null($this->_currentObject)) {
283 + $this->_currentObject->detach();
284 + $this->_currentObject = $this->_currentObjectID = null;
285 + }
286 + // detach ourself from the worksheet, so that it can then delete this object successfully
287 + $this->_parent = null;
288 +
289 + // Close down the temporary cache file
290 + $this->__destruct();
291 + } // function unsetWorksheetCells()
292 +
293 +
294 + /**
295 + * Initialise this new cell collection
296 + *
297 + * @param PHPExcel_Worksheet $parent The worksheet for this cell collection
298 + */
299 + public function __construct(PHPExcel_Worksheet $parent) {
300 + parent::__construct($parent);
301 + if (is_null($this->_DBHandle)) {
302 + $this->_TableName = str_replace('.','_',$this->_getUniqueID());
303 + $_DBName = ':memory:';
304 +
305 + $this->_DBHandle = new SQLite3($_DBName);
306 + if ($this->_DBHandle === false)
307 + throw new PHPExcel_Exception($this->_DBHandle->lastErrorMsg());
308 + if (!$this->_DBHandle->exec('CREATE TABLE kvp_'.$this->_TableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)'))
309 + throw new PHPExcel_Exception($this->_DBHandle->lastErrorMsg());
310 + }
311 +
312 + $this->_selectQuery = $this->_DBHandle->prepare("SELECT value FROM kvp_".$this->_TableName." WHERE id = :id");
313 + $this->_insertQuery = $this->_DBHandle->prepare("INSERT OR REPLACE INTO kvp_".$this->_TableName." VALUES(:id,:data)");
314 + $this->_updateQuery = $this->_DBHandle->prepare("UPDATE kvp_".$this->_TableName." SET id=:toId WHERE id=:fromId");
315 + $this->_deleteQuery = $this->_DBHandle->prepare("DELETE FROM kvp_".$this->_TableName." WHERE id = :id");
316 + } // function __construct()
317 +
318 +
319 + /**
320 + * Destroy this cell collection
321 + */
322 + public function __destruct() {
323 + if (!is_null($this->_DBHandle)) {
324 + $this->_DBHandle->exec('DROP TABLE kvp_'.$this->_TableName);
325 + $this->_DBHandle->close();
326 + }
327 + $this->_DBHandle = null;
328 + } // function __destruct()
329 +
330 +
331 + /**
332 + * Identify whether the caching method is currently available
333 + * Some methods are dependent on the availability of certain extensions being enabled in the PHP build
334 + *
335 + * @return boolean
336 + */
337 + public static function cacheMethodIsAvailable() {
338 + if (!class_exists('SQLite3',FALSE)) {
339 + return false;
340 + }
341 +
342 + return true;
343 + }
344 +
345 +}