1: <?php
  2: /* SVN FILE: $Id$ */
  3: /**
  4:  * SQLite layer for DBO
  5:  *
  6:  * Long description for file
  7:  *
  8:  * PHP versions 4 and 5
  9:  *
 10:  * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
 11:  * Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
 12:  *
 13:  * Licensed under The MIT License
 14:  * Redistributions of files must retain the above copyright notice.
 15:  *
 16:  * @copyright     Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
 17:  * @link          http://cakephp.org CakePHP(tm) Project
 18:  * @package       cake
 19:  * @subpackage    cake.cake.libs.model.datasources.dbo
 20:  * @since         CakePHP(tm) v 0.9.0
 21:  * @version       $Revision$
 22:  * @modifiedby    $LastChangedBy$
 23:  * @lastmodified  $Date$
 24:  * @license       http://www.opensource.org/licenses/mit-license.php The MIT License
 25:  */
 26: /**
 27:  * DBO implementation for the SQLite DBMS.
 28:  *
 29:  * Long description for class
 30:  *
 31:  * @package       cake
 32:  * @subpackage    cake.cake.libs.model.datasources.dbo
 33:  */
 34: class DboSqlite extends DboSource {
 35: /**
 36:  * Enter description here...
 37:  *
 38:  * @var unknown_type
 39:  */
 40:     var $description = "SQLite DBO Driver";
 41: /**
 42:  * Opening quote for quoted identifiers
 43:  *
 44:  * @var string
 45:  */
 46:     var $startQuote = '"';
 47: /**
 48:  * Closing quote for quoted identifiers
 49:  *
 50:  * @var string
 51:  */
 52:     var $endQuote = '"';
 53: /**
 54:  * Keeps the transaction statistics of CREATE/UPDATE/DELETE queries
 55:  *
 56:  * @var array
 57:  * @access protected
 58:  */
 59:     var $_queryStats = array();
 60: /**
 61:  * Base configuration settings for SQLite driver
 62:  *
 63:  * @var array
 64:  */
 65:     var $_baseConfig = array(
 66:         'persistent' => true,
 67:         'database' => null,
 68:         'connect' => 'sqlite_popen'
 69:     );
 70: /**
 71:  * Index of basic SQL commands
 72:  *
 73:  * @var array
 74:  * @access protected
 75:  */
 76:     var $_commands = array(
 77:         'begin'    => 'BEGIN TRANSACTION',
 78:         'commit'   => 'COMMIT TRANSACTION',
 79:         'rollback' => 'ROLLBACK TRANSACTION'
 80:     );
 81: /**
 82:  * SQLite column definition
 83:  *
 84:  * @var array
 85:  */
 86:     var $columns = array(
 87:         'primary_key' => array('name' => 'integer primary key'),
 88:         'string' => array('name' => 'varchar', 'limit' => '255'),
 89:         'text' => array('name' => 'text'),
 90:         'integer' => array('name' => 'integer', 'limit' => 11, 'formatter' => 'intval'),
 91:         'float' => array('name' => 'float', 'formatter' => 'floatval'),
 92:         'datetime' => array('name' => 'datetime', 'format' => 'Y-m-d H:i:s', 'formatter' => 'date'),
 93:         'timestamp' => array('name' => 'timestamp', 'format' => 'Y-m-d H:i:s', 'formatter' => 'date'),
 94:         'time' => array('name' => 'time', 'format' => 'H:i:s', 'formatter' => 'date'),
 95:         'date' => array('name' => 'date', 'format' => 'Y-m-d', 'formatter' => 'date'),
 96:         'binary' => array('name' => 'blob'),
 97:         'boolean' => array('name' => 'boolean')
 98:     );
 99: /**
100:  * Connects to the database using config['database'] as a filename.
101:  *
102:  * @param array $config Configuration array for connecting
103:  * @return mixed
104:  */
105:     function connect() {
106:         $config = $this->config;
107:         $this->connection = $config['connect']($config['database']);
108:         $this->connected = is_resource($this->connection);
109: 
110:         if ($this->connected) {
111:             $this->_execute('PRAGMA count_changes = 1;');
112:         }
113:         return $this->connected;
114:     }
115: /**
116:  * Check that SQLite is enabled/installed
117:  *
118:  * @return boolean
119:  **/
120:     function enabled() {
121:         return extension_loaded('sqlite');
122:     }
123: /**
124:  * Disconnects from database.
125:  *
126:  * @return boolean True if the database could be disconnected, else false
127:  */
128:     function disconnect() {
129:         @sqlite_close($this->connection);
130:         $this->connected = false;
131:         return $this->connected;
132:     }
133: /**
134:  * Executes given SQL statement.
135:  *
136:  * @param string $sql SQL statement
137:  * @return resource Result resource identifier
138:  */
139:     function _execute($sql) {
140:         $result = sqlite_query($this->connection, $sql);
141: 
142:         if (preg_match('/^(INSERT|UPDATE|DELETE)/', $sql)) {
143:             $this->resultSet($result);
144:             list($this->_queryStats) = $this->fetchResult();
145:         }
146:         return $result;
147:     }
148: /**
149:  * Overrides DboSource::execute() to correctly handle query statistics
150:  *
151:  * @param string $sql
152:  * @return unknown
153:  */
154:     function execute($sql) {
155:         $result = parent::execute($sql);
156:         $this->_queryStats = array();
157:         return $result;
158:     }
159: /**
160:  * Returns an array of tables in the database. If there are no tables, an error is raised and the application exits.
161:  *
162:  * @return array Array of tablenames in the database
163:  */
164:     function listSources() {
165:         $cache = parent::listSources();
166: 
167:         if ($cache != null) {
168:             return $cache;
169:         }
170:         $result = $this->fetchAll("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;", false);
171: 
172:         if (empty($result)) {
173:             return array();
174:         } else {
175:             $tables = array();
176:             foreach ($result as $table) {
177:                 $tables[] = $table[0]['name'];
178:             }
179:             parent::listSources($tables);
180:             return $tables;
181:         }
182:         return array();
183:     }
184: /**
185:  * Returns an array of the fields in given table name.
186:  *
187:  * @param string $tableName Name of database table to inspect
188:  * @return array Fields in table. Keys are name and type
189:  */
190:     function describe(&$model) {
191:         $cache = parent::describe($model);
192:         if ($cache != null) {
193:             return $cache;
194:         }
195:         $fields = array();
196:         $result = $this->fetchAll('PRAGMA table_info(' . $this->fullTableName($model) . ')');
197: 
198:         foreach ($result as $column) {
199:             $fields[$column[0]['name']] = array(
200:                 'type' => $this->column($column[0]['type']),
201:                 'null' => !$column[0]['notnull'],
202:                 'default' => $column[0]['dflt_value'],
203:                 'length' => $this->length($column[0]['type'])
204:             );
205:             if ($column[0]['pk'] == 1) {
206:                 $colLength = $this->length($column[0]['type']);
207:                 $fields[$column[0]['name']] = array(
208:                     'type' => $fields[$column[0]['name']]['type'],
209:                     'null' => false,
210:                     'default' => $column[0]['dflt_value'],
211:                     'key' => $this->index['PRI'],
212:                     'length'=> ($colLength != null) ? $colLength : 11
213:                 );
214:             }
215:         }
216: 
217:         $this->__cacheDescription($model->tablePrefix . $model->table, $fields);
218:         return $fields;
219:     }
220: /**
221:  * Returns a quoted and escaped string of $data for use in an SQL statement.
222:  *
223:  * @param string $data String to be prepared for use in an SQL statement
224:  * @return string Quoted and escaped
225:  */
226:     function value($data, $column = null, $safe = false) {
227:         $parent = parent::value($data, $column, $safe);
228: 
229:         if ($parent != null) {
230:             return $parent;
231:         }
232:         if ($data === null) {
233:             return 'NULL';
234:         }
235:         if ($data === '' && $column !== 'integer' && $column !== 'float' && $column !== 'boolean') {
236:             return  "''";
237:         }
238:         switch ($column) {
239:             case 'boolean':
240:                 $data = $this->boolean((bool)$data);
241:             break;
242:             case 'integer':
243:             case 'float':
244:                 if ($data === '') {
245:                     return 'NULL';
246:                 }
247:             default:
248:                 $data = sqlite_escape_string($data);
249:             break;
250:         }
251:         return "'" . $data . "'";
252:     }
253: /**
254:  * Generates and executes an SQL UPDATE statement for given model, fields, and values.
255:  *
256:  * @param Model $model
257:  * @param array $fields
258:  * @param array $values
259:  * @param mixed $conditions
260:  * @return array
261:  */
262:     function update(&$model, $fields = array(), $values = null, $conditions = null) {
263:         if (empty($values) && !empty($fields)) {
264:             foreach ($fields as $field => $value) {
265:                 if (strpos($field, $model->alias . '.') !== false) {
266:                     unset($fields[$field]);
267:                     $field = str_replace($model->alias . '.', "", $field);
268:                     $field = str_replace($model->alias . '.', "", $field);
269:                     $fields[$field] = $value;
270:                 }
271:             }
272:         }
273:         $result = parent::update($model, $fields, $values, $conditions);
274:         return $result;
275:     }
276: /**
277:  * Deletes all the records in a table and resets the count of the auto-incrementing
278:  * primary key, where applicable.
279:  *
280:  * @param mixed $table A string or model class representing the table to be truncated
281:  * @return boolean  SQL TRUNCATE TABLE statement, false if not applicable.
282:  * @access public
283:  */
284:     function truncate($table) {
285:         return $this->execute('DELETE From ' . $this->fullTableName($table));
286:     }
287: /**
288:  * Returns a formatted error message from previous database operation.
289:  *
290:  * @return string Error message
291:  */
292:     function lastError() {
293:         $error = sqlite_last_error($this->connection);
294:         if ($error) {
295:             return $error.': '.sqlite_error_string($error);
296:         }
297:         return null;
298:     }
299: /**
300:  * Returns number of affected rows in previous database operation. If no previous operation exists, this returns false.
301:  *
302:  * @return integer Number of affected rows
303:  */
304:     function lastAffected() {
305:         if (!empty($this->_queryStats)) {
306:             foreach (array('rows inserted', 'rows updated', 'rows deleted') as $key) {
307:                 if (array_key_exists($key, $this->_queryStats)) {
308:                     return $this->_queryStats[$key];
309:                 }
310:             }
311:         }
312:         return false;
313:     }
314: /**
315:  * Returns number of rows in previous resultset. If no previous resultset exists,
316:  * this returns false.
317:  *
318:  * @return integer Number of rows in resultset
319:  */
320:     function lastNumRows() {
321:         if ($this->hasResult()) {
322:             sqlite_num_rows($this->_result);
323:         }
324:         return false;
325:     }
326: /**
327:  * Returns the ID generated from the previous INSERT operation.
328:  *
329:  * @return int
330:  */
331:     function lastInsertId() {
332:         return sqlite_last_insert_rowid($this->connection);
333:     }
334: /**
335:  * Converts database-layer column types to basic types
336:  *
337:  * @param string $real Real database-layer column type (i.e. "varchar(255)")
338:  * @return string Abstract column type (i.e. "string")
339:  */
340:     function column($real) {
341:         if (is_array($real)) {
342:             $col = $real['name'];
343:             if (isset($real['limit'])) {
344:                 $col .= '('.$real['limit'].')';
345:             }
346:             return $col;
347:         }
348: 
349:         $col = strtolower(str_replace(')', '', $real));
350:         $limit = null;
351:         if (strpos($col, '(') !== false) {
352:             list($col, $limit) = explode('(', $col);
353:         }
354: 
355:         if (in_array($col, array('text', 'integer', 'float', 'boolean', 'timestamp', 'date', 'datetime', 'time'))) {
356:             return $col;
357:         }
358:         if (strpos($col, 'varchar') !== false) {
359:             return 'string';
360:         }
361:         if (in_array($col, array('blob', 'clob'))) {
362:             return 'binary';
363:         }
364:         if (strpos($col, 'numeric') !== false) {
365:             return 'float';
366:         }
367:         return 'text';
368:     }
369: /**
370:  * Enter description here...
371:  *
372:  * @param unknown_type $results
373:  */
374:     function resultSet(&$results) {
375:         $this->results =& $results;
376:         $this->map = array();
377:         $fieldCount = sqlite_num_fields($results);
378:         $index = $j = 0;
379: 
380:         while ($j < $fieldCount) {
381:             $columnName = str_replace('"', '', sqlite_field_name($results, $j));
382: 
383:             if (strpos($columnName, '.')) {
384:                 $parts = explode('.', $columnName);
385:                 $this->map[$index++] = array($parts[0], $parts[1]);
386:             } else {
387:                 $this->map[$index++] = array(0, $columnName);
388:             }
389:             $j++;
390:         }
391:     }
392: /**
393:  * Fetches the next row from the current result set
394:  *
395:  * @return unknown
396:  */
397:     function fetchResult() {
398:         if ($row = sqlite_fetch_array($this->results, SQLITE_ASSOC)) {
399:             $resultRow = array();
400:             $i = 0;
401: 
402:             foreach ($row as $index => $field) {
403:                 if (strpos($index, '.')) {
404:                     list($table, $column) = explode('.', str_replace('"', '', $index));
405:                     $resultRow[$table][$column] = $row[$index];
406:                 } else {
407:                     $resultRow[0][str_replace('"', '', $index)] = $row[$index];
408:                 }
409:                 $i++;
410:             }
411:             return $resultRow;
412:         } else {
413:             return false;
414:         }
415:     }
416: /**
417:  * Returns a limit statement in the correct format for the particular database.
418:  *
419:  * @param integer $limit Limit of results returned
420:  * @param integer $offset Offset from which to start results
421:  * @return string SQL limit/offset statement
422:  */
423:     function limit($limit, $offset = null) {
424:         if ($limit) {
425:             $rt = '';
426:             if (!strpos(strtolower($limit), 'limit') || strpos(strtolower($limit), 'limit') === 0) {
427:                 $rt = ' LIMIT';
428:             }
429:             $rt .= ' ' . $limit;
430:             if ($offset) {
431:                 $rt .= ' OFFSET ' . $offset;
432:             }
433:             return $rt;
434:         }
435:         return null;
436:     }
437: /**
438:  * Generate a database-native column schema string
439:  *
440:  * @param array $column An array structured like the following: array('name'=>'value', 'type'=>'value'[, options]),
441:  *                      where options can be 'default', 'length', or 'key'.
442:  * @return string
443:  */
444:     function buildColumn($column) {
445:         $name = $type = null;
446:         $column = array_merge(array('null' => true), $column);
447:         extract($column);
448: 
449:         if (empty($name) || empty($type)) {
450:             trigger_error('Column name or type not defined in schema', E_USER_WARNING);
451:             return null;
452:         }
453: 
454:         if (!isset($this->columns[$type])) {
455:             trigger_error("Column type {$type} does not exist", E_USER_WARNING);
456:             return null;
457:         }
458: 
459:         $real = $this->columns[$type];
460:         $out = $this->name($name) . ' ' . $real['name'];
461:         if (isset($column['key']) && $column['key'] == 'primary' && $type == 'integer') {
462:             return $this->name($name) . ' ' . $this->columns['primary_key']['name'];
463:         }
464:         if (isset($real['limit']) || isset($real['length']) || isset($column['limit']) || isset($column['length'])) {
465:             if (isset($column['length'])) {
466:                 $length = $column['length'];
467:             } elseif (isset($column['limit'])) {
468:                 $length = $column['limit'];
469:             } elseif (isset($real['length'])) {
470:                 $length = $real['length'];
471:             } else {
472:                 $length = $real['limit'];
473:             }
474:             $out .= '(' . $length . ')';
475:         }
476:         if (isset($column['key']) && $column['key'] == 'primary' && $type == 'integer') {
477:             $out .= ' ' . $this->columns['primary_key']['name'];
478:         } elseif (isset($column['key']) && $column['key'] == 'primary') {
479:             $out .= ' NOT NULL';
480:         } elseif (isset($column['default']) && isset($column['null']) && $column['null'] == false) {
481:             $out .= ' DEFAULT ' . $this->value($column['default'], $type) . ' NOT NULL';
482:         } elseif (isset($column['default'])) {
483:             $out .= ' DEFAULT ' . $this->value($column['default'], $type);
484:         } elseif (isset($column['null']) && $column['null'] == true) {
485:             $out .= ' DEFAULT NULL';
486:         } elseif (isset($column['null']) && $column['null'] == false) {
487:             $out .= ' NOT NULL';
488:         }
489:         return $out;
490:     }
491: /**
492:  * Sets the database encoding
493:  *
494:  * @param string $enc Database encoding
495:  */
496:     function setEncoding($enc) {
497:         if (!in_array($enc, array("UTF-8", "UTF-16", "UTF-16le", "UTF-16be"))) {
498:             return false;
499:         }
500:         return $this->_execute("PRAGMA encoding = \"{$enc}\"") !== false;
501:     }
502: /**
503:  * Gets the database encoding
504:  *
505:  * @return string The database encoding
506:  */
507:     function getEncoding() {
508:         return $this->fetchRow('PRAGMA encoding');
509:     }
510: /**
511:  * Removes redundant primary key indexes, as they are handled in the column def of the key.
512:  *
513:  * @param array $indexes
514:  * @param string $table
515:  * @return string
516:  */
517:     function buildIndex($indexes, $table = null) {
518:         $join = array();
519: 
520:         foreach ($indexes as $name => $value) {
521: 
522:             if ($name == 'PRIMARY') {
523:                 continue;
524:             }
525:             $out = 'CREATE ';
526: 
527:             if (!empty($value['unique'])) {
528:                 $out .= 'UNIQUE ';
529:             }
530:             if (is_array($value['column'])) {
531:                 $value['column'] = implode(', ', array_map(array(&$this, 'name'), $value['column']));
532:             } else {
533:                 $value['column'] = $this->name($value['column']);
534:             }
535:             $out .= "INDEX {$name} ON {$table}({$value['column']});";
536:             $join[] = $out;
537:         }
538:         return $join;
539:     }
540: /**
541:  * Overrides DboSource::index to handle SQLite indexe introspection
542:  * Returns an array of the indexes in given table name.
543:  *
544:  * @param string $model Name of model to inspect
545:  * @return array Fields in table. Keys are column and unique
546:  */
547:     function index(&$model) {
548:         $index = array();
549:         $table = $this->fullTableName($model);
550:         if ($table) {
551:             $indexes = $this->query('PRAGMA index_list(' . $table . ')');
552:             $tableInfo = $this->query('PRAGMA table_info(' . $table . ')');
553:             foreach ($indexes as $i => $info) {
554:                 $key = array_pop($info);
555:                 $keyInfo = $this->query('PRAGMA index_info("' . $key['name'] . '")');
556:                 foreach ($keyInfo as $keyCol) {
557:                     if (!isset($index[$key['name']])) {
558:                         $col = array();
559:                         if (preg_match('/autoindex/', $key['name'])) {
560:                             $key['name'] = 'PRIMARY';
561:                         }
562:                         $index[$key['name']]['column'] = $keyCol[0]['name'];
563:                         $index[$key['name']]['unique'] = intval($key['unique'] == 1);
564:                     } else {
565:                         if (!is_array($index[$key['name']]['column'])) {
566:                             $col[] = $index[$key['name']]['column'];
567:                         }
568:                         $col[] = $keyCol[0]['name'];
569:                         $index[$key['name']]['column'] = $col;
570:                     }
571:                 }
572:             }
573:         }
574:         return $index;
575:     }
576:     
577: /**
578:  * Overrides DboSource::renderStatement to handle schema generation with SQLite-style indexes
579:  *
580:  * @param string $type
581:  * @param array $data
582:  * @return string
583:  */
584:     function renderStatement($type, $data) {
585:         switch (strtolower($type)) {
586:             case 'schema':
587:                 extract($data);
588: 
589:                 foreach (array('columns', 'indexes') as $var) {
590:                     if (is_array(${$var})) {
591:                         ${$var} = "\t" . implode(",\n\t", array_filter(${$var}));
592:                     }
593:                 }
594:                 return "CREATE TABLE {$table} (\n{$columns});\n{$indexes}";
595:             break;
596:             default:
597:                 return parent::renderStatement($type, $data);
598:             break;
599:         }
600:     }
601: }
602: ?>