1
|
|
|
<?php |
2
|
|
|
|
3
|
|
|
namespace SilverStripe\SQLite; |
4
|
|
|
|
5
|
|
|
use SilverStripe\ORM\DataList; |
6
|
|
|
use SilverStripe\ORM\ArrayList; |
7
|
|
|
use SilverStripe\ORM\Connect\SS_Database; |
8
|
|
|
use Config; |
9
|
|
|
use Deprecation; |
10
|
|
|
use PaginatedList; |
11
|
|
|
use SilverStripe\ORM\Queries\SQLSelect; |
12
|
|
|
|
13
|
|
|
|
14
|
|
|
/** |
15
|
|
|
* SQLite database controller class |
16
|
|
|
* |
17
|
|
|
* @package SQLite3 |
18
|
|
|
*/ |
19
|
|
|
class SQLite3Database extends SS_Database |
20
|
|
|
{ |
21
|
|
|
|
22
|
|
|
/** |
23
|
|
|
* Database schema manager object |
24
|
|
|
* |
25
|
|
|
* @var SQLite3SchemaManager |
26
|
|
|
*/ |
27
|
|
|
protected $schemaManager = null; |
28
|
|
|
|
29
|
|
|
/* |
30
|
|
|
* This holds the parameters that the original connection was created with, |
31
|
|
|
* so we can switch back to it if necessary (used for unit tests) |
32
|
|
|
* |
33
|
|
|
* @var array |
34
|
|
|
*/ |
35
|
|
|
protected $parameters; |
36
|
|
|
|
37
|
|
|
/* |
38
|
|
|
* if we're on a In-Memory db |
39
|
|
|
* |
40
|
|
|
* @var boolean |
41
|
|
|
*/ |
42
|
|
|
protected $livesInMemory = false; |
43
|
|
|
|
44
|
|
|
/** |
45
|
|
|
* List of default pragma values |
46
|
|
|
* |
47
|
|
|
* @todo Migrate to SS config |
48
|
|
|
* |
49
|
|
|
* @var array |
50
|
|
|
*/ |
51
|
|
|
public static $default_pragma = array( |
52
|
|
|
'encoding' => '"UTF-8"', |
53
|
|
|
'locking_mode' => 'NORMAL' |
54
|
|
|
); |
55
|
|
|
|
56
|
|
|
|
57
|
|
|
/** |
58
|
|
|
* Extension used to distinguish between sqllite database files and other files. |
59
|
|
|
* Required to handle multiple databases. |
60
|
|
|
* |
61
|
|
|
* @return string |
62
|
|
|
*/ |
63
|
|
|
public static function database_extension() |
64
|
|
|
{ |
65
|
|
|
return Config::inst()->get('SQLite3Database', 'database_extension'); |
66
|
|
|
} |
67
|
|
|
|
68
|
|
|
/** |
69
|
|
|
* Check if a database name has a valid extension |
70
|
|
|
* |
71
|
|
|
* @param string $name |
72
|
|
|
* @return boolean |
73
|
|
|
*/ |
74
|
|
|
public static function is_valid_database_name($name) |
75
|
|
|
{ |
76
|
|
|
$extension = self::database_extension(); |
77
|
|
|
if (empty($extension)) { |
78
|
|
|
return true; |
79
|
|
|
} |
80
|
|
|
|
81
|
|
|
return substr_compare($name, $extension, -strlen($extension), strlen($extension)) === 0; |
82
|
|
|
} |
83
|
|
|
|
84
|
|
|
/** |
85
|
|
|
* Connect to a SQLite3 database. |
86
|
|
|
* @param array $parameters An map of parameters, which should include: |
87
|
|
|
* - database: The database to connect to, with the correct file extension (.sqlite) |
88
|
|
|
* - path: the path to the SQLite3 database file |
89
|
|
|
* - key: the encryption key (needs testing) |
90
|
|
|
* - memory: use the faster In-Memory database for unit tests |
91
|
|
|
*/ |
92
|
|
|
public function connect($parameters) |
93
|
|
|
{ |
94
|
|
|
if (!empty($parameters['memory'])) { |
95
|
|
|
Deprecation::notice( |
96
|
|
|
'1.4.0', |
97
|
|
|
"\$databaseConfig['memory'] is deprecated. Use \$databaseConfig['path'] = ':memory:' instead.", |
98
|
|
|
Deprecation::SCOPE_GLOBAL |
99
|
|
|
); |
100
|
|
|
unset($parameters['memory']); |
101
|
|
|
$parameters['path'] = ':memory:'; |
102
|
|
|
} |
103
|
|
|
|
104
|
|
|
//We will store these connection parameters for use elsewhere (ie, unit tests) |
105
|
|
|
$this->parameters = $parameters; |
106
|
|
|
$this->schemaManager->flushCache(); |
107
|
|
|
|
108
|
|
|
// Ensure database name is set |
109
|
|
|
if (empty($parameters['database'])) { |
110
|
|
|
$parameters['database'] = 'database' . self::database_extension(); |
111
|
|
|
} |
112
|
|
|
$dbName = $parameters['database']; |
113
|
|
|
if (!self::is_valid_database_name($dbName)) { |
114
|
|
|
// If not using the correct file extension for database files then the |
115
|
|
|
// results of SQLite3SchemaManager::databaseList will be unpredictable |
116
|
|
|
$extension = self::database_extension(); |
117
|
|
|
Deprecation::notice('3.2', "SQLite3Database now expects a database file with extension \"$extension\". Behaviour may be unpredictable otherwise."); |
118
|
|
|
} |
119
|
|
|
|
120
|
|
|
// use the very lightspeed SQLite In-Memory feature for testing |
121
|
|
|
if ($this->getLivesInMemory()) { |
122
|
|
|
$file = ':memory:'; |
123
|
|
|
} else { |
124
|
|
|
// Ensure path is given |
125
|
|
|
if (empty($parameters['path'])) { |
126
|
|
|
$parameters['path'] = ASSETS_PATH . '/.sqlitedb'; |
127
|
|
|
} |
128
|
|
|
|
129
|
|
|
//assumes that the path to dbname will always be provided: |
130
|
|
|
$file = $parameters['path'] . '/' . $dbName; |
131
|
|
|
if (!file_exists($parameters['path'])) { |
132
|
|
|
SQLiteDatabaseConfigurationHelper::create_db_dir($parameters['path']); |
133
|
|
|
SQLiteDatabaseConfigurationHelper::secure_db_dir($parameters['path']); |
134
|
|
|
} |
135
|
|
|
} |
136
|
|
|
|
137
|
|
|
// 'path' and 'database' are merged into the full file path, which |
138
|
|
|
// is the format that connectors such as PDOConnector expect |
139
|
|
|
$parameters['filepath'] = $file; |
140
|
|
|
|
141
|
|
|
// Ensure that driver is available (required by PDO) |
142
|
|
|
if (empty($parameters['driver'])) { |
143
|
|
|
$parameters['driver'] = $this->getDatabaseServer(); |
144
|
|
|
} |
145
|
|
|
|
146
|
|
|
$this->connector->connect($parameters, true); |
147
|
|
|
|
148
|
|
|
foreach (self::$default_pragma as $pragma => $value) { |
149
|
|
|
$this->setPragma($pragma, $value); |
150
|
|
|
} |
151
|
|
|
|
152
|
|
|
if (empty(self::$default_pragma['locking_mode'])) { |
153
|
|
|
self::$default_pragma['locking_mode'] = $this->getPragma('locking_mode'); |
154
|
|
|
} |
155
|
|
|
} |
156
|
|
|
|
157
|
|
|
/** |
158
|
|
|
* Retrieve parameters used to connect to this SQLLite database |
159
|
|
|
* |
160
|
|
|
* @return array |
161
|
|
|
*/ |
162
|
|
|
public function getParameters() |
163
|
|
|
{ |
164
|
|
|
return $this->parameters; |
165
|
|
|
} |
166
|
|
|
|
167
|
|
|
public function getLivesInMemory() |
168
|
|
|
{ |
169
|
|
|
return isset($this->parameters['path']) && $this->parameters['path'] === ':memory:'; |
170
|
|
|
} |
171
|
|
|
|
172
|
|
|
public function supportsCollations() |
173
|
|
|
{ |
174
|
|
|
return true; |
175
|
|
|
} |
176
|
|
|
|
177
|
|
|
public function supportsTimezoneOverride() |
178
|
|
|
{ |
179
|
|
|
return false; |
180
|
|
|
} |
181
|
|
|
|
182
|
|
|
/** |
183
|
|
|
* Execute PRAGMA commands. |
184
|
|
|
* |
185
|
|
|
* @param string $pragma name |
186
|
|
|
* @param string $value to set |
187
|
|
|
*/ |
188
|
|
|
public function setPragma($pragma, $value) |
189
|
|
|
{ |
190
|
|
|
$this->query("PRAGMA $pragma = $value"); |
191
|
|
|
} |
192
|
|
|
|
193
|
|
|
/** |
194
|
|
|
* Gets pragma value. |
195
|
|
|
* |
196
|
|
|
* @param string $pragma name |
197
|
|
|
* @return string the pragma value |
198
|
|
|
*/ |
199
|
|
|
public function getPragma($pragma) |
200
|
|
|
{ |
201
|
|
|
return $this->query("PRAGMA $pragma")->value(); |
202
|
|
|
} |
203
|
|
|
|
204
|
|
|
public function getDatabaseServer() |
205
|
|
|
{ |
206
|
|
|
return "sqlite"; |
207
|
|
|
} |
208
|
|
|
|
209
|
|
|
public function selectDatabase($name, $create = false, $errorLevel = E_USER_ERROR) |
210
|
|
|
{ |
211
|
|
|
if (!$this->schemaManager->databaseExists($name)) { |
212
|
|
|
// Check DB creation permisson |
213
|
|
|
if (!$create) { |
214
|
|
|
if ($errorLevel !== false) { |
215
|
|
|
user_error("Attempted to connect to non-existing database \"$name\"", $errorLevel); |
216
|
|
|
} |
217
|
|
|
// Unselect database |
218
|
|
|
$this->connector->unloadDatabase(); |
219
|
|
|
return false; |
220
|
|
|
} |
221
|
|
|
$this->schemaManager->createDatabase($name); |
222
|
|
|
} |
223
|
|
|
|
224
|
|
|
// Reconnect using the existing parameters |
225
|
|
|
$parameters = $this->parameters; |
226
|
|
|
$parameters['database'] = $name; |
227
|
|
|
$this->connect($parameters); |
228
|
|
|
return true; |
229
|
|
|
} |
230
|
|
|
|
231
|
|
|
public function now() |
232
|
|
|
{ |
233
|
|
|
return "datetime('now', 'localtime')"; |
234
|
|
|
} |
235
|
|
|
|
236
|
|
|
public function random() |
237
|
|
|
{ |
238
|
|
|
return 'random()'; |
239
|
|
|
} |
240
|
|
|
|
241
|
|
|
/** |
242
|
|
|
* The core search engine configuration. |
243
|
|
|
* @todo There is a fulltext search for SQLite making use of virtual tables, the fts3 extension and the |
244
|
|
|
* MATCH operator |
245
|
|
|
* there are a few issues with fts: |
246
|
|
|
* - shared cached lock doesn't allow to create virtual tables on versions prior to 3.6.17 |
247
|
|
|
* - there must not be more than one MATCH operator per statement |
248
|
|
|
* - the fts3 extension needs to be available |
249
|
|
|
* for now we use the MySQL implementation with the MATCH()AGAINST() uglily replaced with LIKE |
250
|
|
|
* |
251
|
|
|
* @param array $classesToSearch |
252
|
|
|
* @param string $keywords Keywords as a space separated string |
253
|
|
|
* @param int $start |
254
|
|
|
* @param int $pageLength |
255
|
|
|
* @param string $sortBy |
256
|
|
|
* @param string $extraFilter |
257
|
|
|
* @param bool $booleanSearch |
258
|
|
|
* @param string $alternativeFileFilter |
259
|
|
|
* @param bool $invertedMatch |
260
|
|
|
* @return PaginatedList DataObjectSet of result pages |
261
|
|
|
*/ |
262
|
|
|
public function searchEngine($classesToSearch, $keywords, $start, $pageLength, $sortBy = "Relevance DESC", |
263
|
|
|
$extraFilter = "", $booleanSearch = false, $alternativeFileFilter = "", $invertedMatch = false |
264
|
|
|
) { |
265
|
|
|
$keywords = $this->escapeString(str_replace(array('*', '+', '-', '"', '\''), '', $keywords)); |
266
|
|
|
$htmlEntityKeywords = htmlentities(utf8_decode($keywords)); |
267
|
|
|
|
268
|
|
|
$extraFilters = array('SiteTree' => '', 'File' => ''); |
269
|
|
|
|
270
|
|
|
if ($extraFilter) { |
271
|
|
|
$extraFilters['SiteTree'] = " AND $extraFilter"; |
272
|
|
|
|
273
|
|
|
if ($alternativeFileFilter) { |
274
|
|
|
$extraFilters['File'] = " AND $alternativeFileFilter"; |
275
|
|
|
} else { |
276
|
|
|
$extraFilters['File'] = $extraFilters['SiteTree']; |
277
|
|
|
} |
278
|
|
|
} |
279
|
|
|
|
280
|
|
|
// Always ensure that only pages with ShowInSearch = 1 can be searched |
281
|
|
|
$extraFilters['SiteTree'] .= ' AND ShowInSearch <> 0'; |
282
|
|
|
// File.ShowInSearch was added later, keep the database driver backwards compatible |
283
|
|
|
// by checking for its existence first |
284
|
|
|
$fields = $this->getSchemaManager()->fieldList('File'); |
285
|
|
|
if (array_key_exists('ShowInSearch', $fields)) { |
286
|
|
|
$extraFilters['File'] .= " AND ShowInSearch <> 0"; |
287
|
|
|
} |
288
|
|
|
|
289
|
|
|
$limit = $start . ", " . (int) $pageLength; |
290
|
|
|
|
291
|
|
|
$notMatch = $invertedMatch ? "NOT " : ""; |
292
|
|
|
if ($keywords) { |
293
|
|
|
$match['SiteTree'] = " |
|
|
|
|
294
|
|
|
(Title LIKE '%$keywords%' OR MenuTitle LIKE '%$keywords%' OR Content LIKE '%$keywords%' OR MetaDescription LIKE '%$keywords%' OR |
295
|
|
|
Title LIKE '%$htmlEntityKeywords%' OR MenuTitle LIKE '%$htmlEntityKeywords%' OR Content LIKE '%$htmlEntityKeywords%' OR MetaDescription LIKE '%$htmlEntityKeywords%') |
296
|
|
|
"; |
297
|
|
|
$match['File'] = "(Name LIKE '%$keywords%' OR Title LIKE '%$keywords%') AND ClassName = 'File'"; |
298
|
|
|
|
299
|
|
|
// We make the relevance search by converting a boolean mode search into a normal one |
300
|
|
|
$relevanceKeywords = $keywords; |
301
|
|
|
$htmlEntityRelevanceKeywords = $htmlEntityKeywords; |
302
|
|
|
$relevance['SiteTree'] = "(Title LIKE '%$relevanceKeywords%' OR MenuTitle LIKE '%$relevanceKeywords%' OR Content LIKE '%$relevanceKeywords%' OR MetaDescription LIKE '%$relevanceKeywords%') + (Title LIKE '%$htmlEntityRelevanceKeywords%' OR MenuTitle LIKE '%$htmlEntityRelevanceKeywords%' OR Content LIKE '%$htmlEntityRelevanceKeywords%' OR MetaDescription LIKE '%$htmlEntityRelevanceKeywords%')"; |
|
|
|
|
303
|
|
|
$relevance['File'] = "(Name LIKE '%$relevanceKeywords%' OR Title LIKE '%$relevanceKeywords%')"; |
304
|
|
|
} else { |
305
|
|
|
$relevance['SiteTree'] = $relevance['File'] = 1; |
|
|
|
|
306
|
|
|
$match['SiteTree'] = $match['File'] = "1 = 1"; |
|
|
|
|
307
|
|
|
} |
308
|
|
|
|
309
|
|
|
// Generate initial queries and base table names |
310
|
|
|
$baseClasses = array('SiteTree' => '', 'File' => ''); |
311
|
|
|
$queries = array(); |
312
|
|
|
foreach ($classesToSearch as $class) { |
313
|
|
|
$queries[$class] = DataList::create($class) |
314
|
|
|
->where($notMatch . $match[$class] . $extraFilters[$class]) |
315
|
|
|
->dataQuery() |
316
|
|
|
->query(); |
317
|
|
|
$fromArr = $queries[$class]->getFrom(); |
318
|
|
|
$baseClasses[$class] = reset($fromArr); |
319
|
|
|
} |
320
|
|
|
|
321
|
|
|
// Make column selection lists |
322
|
|
|
$select = array( |
323
|
|
|
'SiteTree' => array( |
324
|
|
|
"\"ClassName\"", |
325
|
|
|
"\"ID\"", |
326
|
|
|
"\"ParentID\"", |
327
|
|
|
"\"Title\"", |
328
|
|
|
"\"URLSegment\"", |
329
|
|
|
"\"Content\"", |
330
|
|
|
"\"LastEdited\"", |
331
|
|
|
"\"Created\"", |
332
|
|
|
"NULL AS \"Name\"", |
333
|
|
|
"\"CanViewType\"", |
334
|
|
|
"$relevance[SiteTree] AS Relevance" |
335
|
|
|
), |
336
|
|
|
'File' => array( |
337
|
|
|
"\"ClassName\"", |
338
|
|
|
"\"ID\"", |
339
|
|
|
"NULL AS \"ParentID\"", |
340
|
|
|
"\"Title\"", |
341
|
|
|
"NULL AS \"URLSegment\"", |
342
|
|
|
"NULL AS \"Content\"", |
343
|
|
|
"\"LastEdited\"", |
344
|
|
|
"\"Created\"", |
345
|
|
|
"\"Name\"", |
346
|
|
|
"NULL AS \"CanViewType\"", |
347
|
|
|
"$relevance[File] AS Relevance" |
348
|
|
|
) |
349
|
|
|
); |
350
|
|
|
|
351
|
|
|
// Process queries |
352
|
|
|
foreach ($classesToSearch as $class) { |
353
|
|
|
// There's no need to do all that joining |
354
|
|
|
$queries[$class]->setFrom($baseClasses[$class]); |
355
|
|
|
|
356
|
|
|
$queries[$class]->setSelect(array()); |
357
|
|
|
foreach ($select[$class] as $clause) { |
358
|
|
|
if (preg_match('/^(.*) +AS +"?([^"]*)"?/i', $clause, $matches)) { |
359
|
|
|
$queries[$class]->selectField($matches[1], $matches[2]); |
360
|
|
|
} else { |
361
|
|
|
$queries[$class]->selectField(str_replace('"', '', $clause)); |
362
|
|
|
} |
363
|
|
|
} |
364
|
|
|
|
365
|
|
|
$queries[$class]->setOrderBy(array()); |
366
|
|
|
} |
367
|
|
|
|
368
|
|
|
// Combine queries |
369
|
|
|
$querySQLs = array(); |
370
|
|
|
$queryParameters = array(); |
371
|
|
|
$totalCount = 0; |
372
|
|
|
foreach ($queries as $query) { |
373
|
|
|
/** @var SQLSelect $query */ |
374
|
|
|
$querySQLs[] = $query->sql($parameters); |
|
|
|
|
375
|
|
|
$queryParameters = array_merge($queryParameters, $parameters); |
|
|
|
|
376
|
|
|
$totalCount += $query->unlimitedRowCount(); |
377
|
|
|
} |
378
|
|
|
|
379
|
|
|
$fullQuery = implode(" UNION ", $querySQLs) . " ORDER BY $sortBy LIMIT $limit"; |
380
|
|
|
// Get records |
381
|
|
|
$records = $this->preparedQuery($fullQuery, $queryParameters); |
382
|
|
|
|
383
|
|
|
foreach ($records as $record) { |
384
|
|
|
$objects[] = new $record['ClassName']($record); |
|
|
|
|
385
|
|
|
} |
386
|
|
|
|
387
|
|
|
if (isset($objects)) { |
388
|
|
|
$doSet = new ArrayList($objects); |
389
|
|
|
} else { |
390
|
|
|
$doSet = new ArrayList(); |
391
|
|
|
} |
392
|
|
|
$list = new PaginatedList($doSet); |
393
|
|
|
$list->setPageStart($start); |
394
|
|
|
$list->setPageLength($pageLength); |
395
|
|
|
$list->setTotalItems($totalCount); |
396
|
|
|
return $list; |
397
|
|
|
} |
398
|
|
|
|
399
|
|
|
/* |
400
|
|
|
* Does this database support transactions? |
401
|
|
|
*/ |
402
|
|
|
public function supportsTransactions() |
403
|
|
|
{ |
404
|
|
|
return version_compare($this->getVersion(), '3.6', '>='); |
405
|
|
|
} |
406
|
|
|
|
407
|
|
|
public function supportsExtensions($extensions = array('partitions', 'tablespaces', 'clustering')) |
408
|
|
|
{ |
409
|
|
|
if (isset($extensions['partitions'])) { |
410
|
|
|
return true; |
411
|
|
|
} elseif (isset($extensions['tablespaces'])) { |
412
|
|
|
return true; |
413
|
|
|
} elseif (isset($extensions['clustering'])) { |
414
|
|
|
return true; |
415
|
|
|
} else { |
416
|
|
|
return false; |
417
|
|
|
} |
418
|
|
|
} |
419
|
|
|
|
420
|
|
|
public function transactionStart($transaction_mode = false, $session_characteristics = false) |
421
|
|
|
{ |
422
|
|
|
$this->query('BEGIN'); |
423
|
|
|
} |
424
|
|
|
|
425
|
|
|
public function transactionSavepoint($savepoint) |
426
|
|
|
{ |
427
|
|
|
$this->query("SAVEPOINT \"$savepoint\""); |
428
|
|
|
} |
429
|
|
|
|
430
|
|
|
public function transactionRollback($savepoint = false) |
431
|
|
|
{ |
432
|
|
|
if ($savepoint) { |
433
|
|
|
$this->query("ROLLBACK TO $savepoint;"); |
434
|
|
|
} else { |
435
|
|
|
$this->query('ROLLBACK;'); |
436
|
|
|
} |
437
|
|
|
} |
438
|
|
|
|
439
|
|
|
public function transactionEnd($chain = false) |
440
|
|
|
{ |
441
|
|
|
$this->query('COMMIT;'); |
442
|
|
|
} |
443
|
|
|
|
444
|
|
|
public function clearTable($table) |
445
|
|
|
{ |
446
|
|
|
$this->query("DELETE FROM \"$table\""); |
447
|
|
|
} |
448
|
|
|
|
449
|
|
|
public function comparisonClause($field, $value, $exact = false, $negate = false, $caseSensitive = null, |
450
|
|
|
$parameterised = false |
451
|
|
|
) { |
452
|
|
|
if ($exact && !$caseSensitive) { |
453
|
|
|
$comp = ($negate) ? '!=' : '='; |
454
|
|
|
} else { |
455
|
|
|
if ($caseSensitive) { |
456
|
|
|
// GLOB uses asterisks as wildcards. |
457
|
|
|
// Replace them in search string, without replacing escaped percetage signs. |
458
|
|
|
$comp = 'GLOB'; |
459
|
|
|
$value = preg_replace('/^%([^\\\\])/', '*$1', $value); |
460
|
|
|
$value = preg_replace('/([^\\\\])%$/', '$1*', $value); |
461
|
|
|
$value = preg_replace('/([^\\\\])%/', '$1*', $value); |
462
|
|
|
} else { |
463
|
|
|
$comp = 'LIKE'; |
464
|
|
|
} |
465
|
|
|
if ($negate) { |
466
|
|
|
$comp = 'NOT ' . $comp; |
467
|
|
|
} |
468
|
|
|
} |
469
|
|
|
|
470
|
|
|
if ($parameterised) { |
471
|
|
|
return sprintf("%s %s ?", $field, $comp); |
472
|
|
|
} else { |
473
|
|
|
return sprintf("%s %s '%s'", $field, $comp, $value); |
474
|
|
|
} |
475
|
|
|
} |
476
|
|
|
|
477
|
|
|
public function formattedDatetimeClause($date, $format) |
|
|
|
|
478
|
|
|
{ |
479
|
|
|
preg_match_all('/%(.)/', $format, $matches); |
480
|
|
|
foreach ($matches[1] as $match) { |
481
|
|
|
if (array_search($match, array('Y', 'm', 'd', 'H', 'i', 's', 'U')) === false) { |
482
|
|
|
user_error('formattedDatetimeClause(): unsupported format character %' . $match, E_USER_WARNING); |
483
|
|
|
} |
484
|
|
|
} |
485
|
|
|
|
486
|
|
|
$translate = array( |
487
|
|
|
'/%i/' => '%M', |
488
|
|
|
'/%s/' => '%S', |
489
|
|
|
'/%U/' => '%s', |
490
|
|
|
); |
491
|
|
|
$format = preg_replace(array_keys($translate), array_values($translate), $format); |
492
|
|
|
|
493
|
|
|
$modifiers = array(); |
494
|
|
|
if ($format == '%s' && $date != 'now') { |
495
|
|
|
$modifiers[] = 'utc'; |
496
|
|
|
} |
497
|
|
|
if ($format != '%s' && $date == 'now') { |
498
|
|
|
$modifiers[] = 'localtime'; |
499
|
|
|
} |
500
|
|
|
|
501
|
|
View Code Duplication |
if (preg_match('/^now$/i', $date)) { |
|
|
|
|
502
|
|
|
$date = "'now'"; |
503
|
|
|
} elseif (preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date)) { |
504
|
|
|
$date = "'$date'"; |
505
|
|
|
} |
506
|
|
|
|
507
|
|
|
$modifier = empty($modifiers) ? '' : ", '" . implode("', '", $modifiers) . "'"; |
508
|
|
|
return "strftime('$format', $date$modifier)"; |
509
|
|
|
} |
510
|
|
|
|
511
|
|
|
public function datetimeIntervalClause($date, $interval) |
|
|
|
|
512
|
|
|
{ |
513
|
|
|
$modifiers = array(); |
514
|
|
|
if ($date == 'now') { |
515
|
|
|
$modifiers[] = 'localtime'; |
516
|
|
|
} |
517
|
|
|
|
518
|
|
View Code Duplication |
if (preg_match('/^now$/i', $date)) { |
|
|
|
|
519
|
|
|
$date = "'now'"; |
520
|
|
|
} elseif (preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date)) { |
521
|
|
|
$date = "'$date'"; |
522
|
|
|
} |
523
|
|
|
|
524
|
|
|
$modifier = empty($modifiers) ? '' : ", '" . implode("', '", $modifiers) . "'"; |
525
|
|
|
return "datetime($date$modifier, '$interval')"; |
526
|
|
|
} |
527
|
|
|
|
528
|
|
|
public function datetimeDifferenceClause($date1, $date2) |
|
|
|
|
529
|
|
|
{ |
530
|
|
|
$modifiers1 = array(); |
531
|
|
|
$modifiers2 = array(); |
532
|
|
|
|
533
|
|
|
if ($date1 == 'now') { |
534
|
|
|
$modifiers1[] = 'localtime'; |
535
|
|
|
} |
536
|
|
|
if ($date2 == 'now') { |
537
|
|
|
$modifiers2[] = 'localtime'; |
538
|
|
|
} |
539
|
|
|
|
540
|
|
|
if (preg_match('/^now$/i', $date1)) { |
541
|
|
|
$date1 = "'now'"; |
542
|
|
|
} elseif (preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date1)) { |
543
|
|
|
$date1 = "'$date1'"; |
544
|
|
|
} |
545
|
|
|
|
546
|
|
|
if (preg_match('/^now$/i', $date2)) { |
547
|
|
|
$date2 = "'now'"; |
548
|
|
|
} elseif (preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date2)) { |
549
|
|
|
$date2 = "'$date2'"; |
550
|
|
|
} |
551
|
|
|
|
552
|
|
|
$modifier1 = empty($modifiers1) ? '' : ", '" . implode("', '", $modifiers1) . "'"; |
553
|
|
|
$modifier2 = empty($modifiers2) ? '' : ", '" . implode("', '", $modifiers2) . "'"; |
554
|
|
|
|
555
|
|
|
return "strftime('%s', $date1$modifier1) - strftime('%s', $date2$modifier2)"; |
556
|
|
|
} |
557
|
|
|
} |
558
|
|
|
|
Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code.
Let’s take a look at an example:
As you can see in this example, the array
$myArray
is initialized the first time when the foreach loop is entered. You can also see that the value of thebar
key is only written conditionally; thus, its value might result from a previous iteration.This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization $myArray = array() either outside or inside the foreach loop.