commit 3e00f686c42988ae4f841eaac61ca69160b9efc5 Author: Damien Tournoud Date: Wed Nov 5 18:18:47 2008 +0100 SQLite patch. diff --git includes/database/database.inc includes/database/database.inc index b36747a..9ec2138 100644 --- includes/database/database.inc +++ includes/database/database.inc @@ -160,7 +160,9 @@ abstract class DatabaseConnection extends PDO { $driver_options[PDO::ATTR_ERRMODE] = PDO::ERRMODE_EXCEPTION; // Call PDO::__construct and PDO::setAttribute. parent::__construct($dsn, $username, $password, $driver_options); - $this->setAttribute(PDO::ATTR_STATEMENT_CLASS, array('DatabaseStatement', array($this))); + if (!isset($driver_options['use_default_statement'])) { + $this->setAttribute(PDO::ATTR_STATEMENT_CLASS, array('DatabaseStatement', array($this))); + } } /** @@ -396,6 +398,9 @@ abstract class DatabaseConnection extends PDO { else { $stmt = $this->prepareQuery($query); $stmt->execute($args, $options); + if (!($stmt instanceof DatabaseStatement_sqlite)) { + die("is sql!"); + } } // Depending on the type of query we may need to return a different value. @@ -562,7 +567,7 @@ abstract class DatabaseConnection extends PDO { * The sanitized table name string. */ public function escapeTable($table) { - return preg_replace('/[^A-Za-z0-9_]+/', '', $string); + return preg_replace('/[^A-Za-z0-9_]+/', '', $table); } /** @@ -2016,15 +2021,15 @@ function _db_error_page($error = '') { * @{ */ -function db_fetch_object(DatabaseStatement $statement) { +function db_fetch_object($statement) { return $statement->fetch(PDO::FETCH_OBJ); } -function db_fetch_array(DatabaseStatement $statement) { +function db_fetch_array($statement) { return $statement->fetch(PDO::FETCH_ASSOC); } -function db_result(DatabaseStatement $statement) { +function db_result($statement) { return $statement->fetchField(); } diff --git includes/database/log.inc includes/database/log.inc index 6617d81..64873ca 100644 --- includes/database/log.inc +++ includes/database/log.inc @@ -113,7 +113,7 @@ class DatabaseLog { * @param $time * The time in milliseconds the query took to execute. */ - public function log(DatabaseStatement $statement, $args, $time) { + public function log($statement, $args, $time) { foreach (array_keys($this->queryLog) as $key) { $this->queryLog[$key][] = array( 'query' => $statement->queryString, diff --git includes/database/query.inc includes/database/query.inc index f3270a0..9743535 100644 --- includes/database/query.inc +++ includes/database/query.inc @@ -650,7 +650,6 @@ class MergeQuery extends Query { $arguments = $select->getArguments(); $num_existing = db_query($sql, $arguments)->fetchField(); - if ($num_existing) { // If there is already an existing record, run an update query. diff --git includes/database/sqlite/database.inc includes/database/sqlite/database.inc new file mode 100644 index 0000000..8b4c7c7 --- /dev/null +++ includes/database/sqlite/database.inc @@ -0,0 +1,465 @@ +exec('PRAGMA encoding="UTF-8"'); + $this->sqliteCreateFunction('length', 'strlen', 1); + $this->sqliteCreateFunction('substring', '_sqlite_substring', 3); + $this->sqliteCreateFunction('greatest', 'max'); + $this->sqliteCreateFunction('pow', 'pow', 2); + } + + public function query($query, Array $args = array(), $options = array()) { + // XXX: make this work when $query is a DatabaseStatement_sqlite, ie. not a DatabaseStatement! + return parent::query($query, $args, $options); + } + + public function prepare($query, Array $options = array()) { + return new DatabaseStatement_sqlite($this, $query, $options); + } + + public function _prepare($query, Array $options = array()) { + return parent::prepare($query, $options); + } + + public function queryRange($query, Array $args, $from, $count, Array $options) { + // Backward compatibility hack, temporary. + $query = str_replace(array('%d' , '%f' , '%b' , "'%s'"), '?', $query); + + return $this->query($query . ' LIMIT ' . $from . ', ' . $count, $args, $options); + } + + public function queryTemporary($query, Array $args, $tablename, $options = array()) { + $query = preg_replace('/^SELECT/i', 'CREATE TEMPORARY TABLE ' . $tablename . ' SELECT', $this->prefixTables($query)); + + return $this->query($query, $args, $options); + } + + public function driver() { + return 'sqlite'; + } + + public function databaseType() { + return 'sqlite'; + } + + public function supportsTransactions() { + return TRUE; + } + + public function mapConditionOperator($operator) { + // We don't want to override any of the defaults. + return NULL; + } + + protected function prepareQuery($query) { + // We skip the query cache, because it keeps reference to executed statement, + // and the locking system of SQLite doesn't support that. + return $this->prepare($this->prefixTables($query)); + } + + /** + * @todo Remove this as soon as db_rewrite_sql() has been exterminated. + */ + public function distinctField($table, $field, $query) { + $field_to_select = 'DISTINCT(' . $table . '.' . $field . ')'; + // (?dbh = $database_connection; + $this->setFetchMode(PDO::FETCH_OBJ); + $this->queryString = $query; + $this->driver_options = $driver_options; + } + + protected $data = array(); + protected $processed_data = NULL; + protected $cursor = 0; + protected $columnCount = NULL; + protected $rowCount = NULL; + + protected $default_fetch_style = PDO::FETCH_BOTH; + protected $default_fetch_options = array( + 'class' => 'stdClass', + 'constructor_args' => array(), + 'object' => NULL, + 'column' => 0, + ); + + public function setFetchMode($fetch_style, $a2 = NULL, $a3 = NULL) { + $this->default_fetch_style = $fetch_style; + switch ($fetch_style) { + case PDO::FETCH_CLASS: + $this->default_fetch_options['class'] = $a2; + if ($a3) { + $this->default_fetch_options['constructor_args'] = $a3; + } + break; + case PDO::FETCH_COLUMN: + $this->default_fetch_options['column'] = $a2; + break; + case PDO::FETCH_INTO: + $this->default_fetch_options['object'] = $a2; + break; + } + $this->processed_data = NULL; + } + + public function fetchAll($fetch_style = NULL, $fetch_column = NULL, $constructor_args = NULL) { + if (!isset($fetch_style)) { + $fetch_style = $this->default_fetch_style; + } + $fetch_options = $this->default_fetch_options; + if (isset($fetch_column)) { + $fetch_options['column'] = $fetch_column; + } + if (isset($constructor_args)) { + $fetch_options['constructor_args'] = $constructor_args; + } + + return $this->fetchHelper($this->data, FALSE, $fetch_style, $fetch_options); + } + + public function fetch($fetch_style = NULL, $cursor_orientation = PDO::FETCH_ORI_NEXT, $cursor_offset = NULL) { + if (isset($this->data[$this->cursor])) { + $return = $this->fetchHelper($this->data[$this->cursor], TRUE, $fetch_style); + $this->cursor++; + return $return; + } + } + + public function fetchObject($class_name = NULL, $constructor_args = array()) { + if (isset($this->data[$this->cursor])) { + if (isset($class_name)) { + $result = $this->fetchHelper($this->data[$this->cursor], TRUE, PDO::FETCH_CLASS, array('class' => $class_name, 'constructor_args' => $constructor_args)); + } + else { + $result = $this->fetchHelper($this->data[$this->cursor], TRUE, PDO::FETCH_OBJ, array()); + } + $this->cursor++; + return $result; + } + } + + public function current() { + if (is_null($this->processed_data)) { + $this->processed_data = $this->fetchHelper($this->data, FALSE); + } + return $this->processed_data[$this->cursor]; + } + + public function key() { + return $this->cursor; + } + + public function rewind() { + $this->cursor = 0; + } + + public function next() { + $this->cursor++; + } + + public function valid() { + if (is_null($this->processed_data)) { + $this->processed_data = $this->fetchHelper($this->data, FALSE); + } + return isset($this->processed_data[$this->cursor]); + } + + protected function fetchHelper($rows, $scalar_mode, $fetch_style = NULL, $fetch_options = NULL) { + if (is_null($fetch_style)) { + $fetch_style = $this->default_fetch_style; + } + if (is_null($fetch_options)) { + $fetch_options = $this->default_fetch_options; + } + if (!$scalar_mode && !count($rows)) { + return array(); + } + if ($scalar_mode) { + $rows = array($rows); + } + switch ($fetch_style) { + case PDO::FETCH_ASSOC: + break; + case PDO::FETCH_BOTH: + foreach ($rows as $k => $row) { + $rows[$k] = $row + array_values($row); + } + break; + case PDO::FETCH_CLASS | PDO::FETCH_CLASSTYPE: + $class_name = array_unshift($row); + // Deliberate no break. + case PDO::FETCH_CLASS: + $reflector = new ReflectionClass($fetch_options['class']); + foreach ($rows as $k => $row) { + if (count($fetch_options['constructor_args'])) { + $result = $reflector->newInstanceArgs($fetch_options['constructor_args']); + } + else { + $class_name = $fetch_options['class']; + $result = new $class_name(); + } + foreach ($row as $k1 => $v) { + $result->$k1 = $v; + } + $rows[$k] = $result; + } + break; + case PDO::FETCH_INTO: + $row = current($rows); + foreach ($row as $k => $v) { + $fetch_options['object']->$k = $v; + } + break; + case PDO::FETCH_COLUMN: + $i = 0; + foreach (current($rows) as $column => $value) { + if ($i >= $fetch_options['column']) break; + $i++; + } + foreach (array_keys($rows) as $k) { + $rows[$k] = $rows[$k][$column]; + } + break; + case PDO::FETCH_NUM: + foreach ($rows as $k => $row) { + $rows[$k] = array_values($row); + } + break; + case PDO::FETCH_LAZY: + // We are not doing lazy. We already retrieved everything, anyways. + case PDO::FETCH_OBJ: + foreach ($rows as $k => $row) { + $rows[$k] = (object)$row; + } + break; + } + if ($scalar_mode) { + return current($rows); + } + else { + return $rows; + } + } + + public function rowCount() { + return $this->rowCount; + } + + public function getAttribute($attribute) { + return NULL; + } + + public function getColumnMeta($column) { + return NULL; + } + + public function nextRowset() { + return FALSE; + } + + public function columnCount() { + return $this->columnCount; + } + + /** + * @see DatabaseStatement::fetchCol(). + */ + public function fetchCol($index = 0) { + return $this->fetchHelper($this->data, FALSE, PDO::FETCH_COLUMN, array('column' => $index)); + } + + /** + * @see PDOStatement->fetchColumn. + */ + public function fetchColumn($index = 0) { + if (isset($this->data[$this->cursor])) { + $return = $this->fetchHelper($this->data[$this->cursor], TRUE, PDO::FETCH_COLUMN, array('column' => $index)); + $this->cursor++; + return $return; + } + } + + /** + * @see DatabaseStatement::fetchField(). + */ + public function fetchField($index = 0) { + // Call PDOStatement::fetchColumn to fetch the field. + return $this->fetchColumn($index); + } + + /** + * @see DatabaseStatement::fetchAllAssoc(). + */ + public function fetchAllAssoc($key, $fetch = PDO::FETCH_OBJ) { + $return = array(); + $this->setFetchMode($fetch); + if (in_array($fetch, array(PDO::FETCH_ASSOC, PDO::FETCH_NUM, PDO::FETCH_BOTH))) { + foreach ($this as $record) { + $return[$record[$key]] = $record; + } + } + else { + foreach ($this as $record) { + $return[$record->$key] = $record; + } + } + return $return; + } + + /** + * @see DatabaseStatement::fetchAllKeyed(). + */ + public function fetchAllKeyed($key_index = 0, $value_index = 1) { + $return = array(); + $this->setFetchMode(PDO::FETCH_NUM); + foreach ($this as $record) { + $return[$record[$key_index]] = $record[$value_index]; + } + return $return; + } + + + /** + * @see DatabaseStatement::fetchAssoc(). + */ + public function fetchAssoc() { + // Call PDOStatement::fetch to fetch the row. + return $this->fetch(PDO::FETCH_ASSOC); + } + + /** + * Replace numeric arguments in the query to workaround a bug in the PDO SQlite implementation. + * + * @param $query + * @param $args + */ + protected function preparseQuery($query, $args) { + // XXX: Ok, this is horrible, but works for now. + // This means: all keys are numeric. + if (preg_match('/^[0-9]+$/', implode('', array_keys($args)))) { + // Unnamed placeholders. + $count = 0; + $new_args = array(); + foreach ($args as $value) { + if (is_numeric($value)) { + $query = substr_replace($query, $value, strpos($query, '?'), 1); + } + else { + $placeholder = ':placeholder_' . $count++; + $query = substr_replace($query, $placeholder, strpos($query, '?'), 1); + $new_args[$placeholder] = $value; + } + } + $args = $new_args; + } + else { + // Named placeholders. + foreach ($args as $placeholder => $value) { + if (is_numeric($value)) { + $query = str_replace($placeholder, $value, $query); + unset($args[$placeholder]); + } + } + } + return array($query, $args); + } + + /** + * Executes a prepared statement + * + * @param $args + * An array of values with as many elements as there are bound parameters in the SQL statement being executed. + * @param $options + * An array of options for this query. + * @return + * TRUE on success, or FALSE on failure. + */ + public function execute($args, $options) { + list($query, $args) = $this->preparseQuery($this->queryString, $args); + $statement = $this->dbh->_prepare($query); + + if (isset($options['fetch'])) { + if (is_string($options['fetch'])) { + // Default to an object. Note: db fields will be added to the object + // before the constructor is run. If you need to assign fields after + // the constructor is run, see http://drupal.org/node/315092. + $this->setFetchMode(PDO::FETCH_CLASS, $options['fetch']); + } + else { + $this->setFetchMode($options['fetch']); + } + } + $this->dbh->lastStatement = $this; + + $logger = $this->dbh->getLogger(); + if (!empty($logger)) { + $query_start = microtime(TRUE); + } + + $display_args = $args; + foreach ($display_args as $k => $v) { + $display_args[$k] = "$k=$v"; + } + $display_args = implode(' | ', $display_args); + // error_log($query . " " . $display_args); + + $return = $statement->execute($args, $options); + $this->rowCount = $statement->rowCount(); + $this->columnCount = $statement->columnCount(); + $this->data = $statement->fetchAll(PDO::FETCH_ASSOC); + + if (is_null($this->data)) { + $this->data = array(); + } + + foreach ($this->data as $k => $row) { + foreach (array_keys($row) as $column) { + if (preg_match("/^.*\.(.*)$/", $column, $matches)) { + $this->data[$k][$matches[1]] = $this->data[$k][$column]; + unset($this->data[$k][$column]); + } + } + } + // XXX: $this->metadata = ... + + if (!empty($logger)) { + $query_end = microtime(TRUE); + $logger->log($this, $args, $query_end - $query_start); + } + + return $return; + } +} + +/** + * @} End of "ingroup database". + */ diff --git includes/database/sqlite/install.inc includes/database/sqlite/install.inc new file mode 100644 index 0000000..0eaac20 --- /dev/null +++ includes/database/sqlite/install.inc @@ -0,0 +1,12 @@ +insertFields)) { + return parent::execute(); + } + else { + return $this->connection->query('INSERT INTO {'. $this->table .'} DEFAULT VALUES', array(), $this->queryOptions); + } + } + + public function __toString() { + $placeholders = array_pad(array(), count($this->insertFields), '?'); + return 'INSERT INTO {'. $this->table .'} ('. implode(', ', $this->insertFields) .') VALUES ('. implode(', ', $placeholders) .')'; + } + +} + +class UpdateQuery_sqlite extends UpdateQuery { + + public function execute() { + $conditions = $this->condition->conditions(); + $fields = $this->expressionFields + $this->fields; + foreach ($conditions as $condition) { + unset($fields[$condition['field']]); + } + + $condition = db_or(); + foreach ($fields as $field => $data) { + $condition->condition($field, is_array($data) ? $data['expression'] : $data, '<>'); + } + if (count($condition)) { + $condition->compile($this->connection); + $this->condition->where((string)$condition, $condition->arguments()); + } + return parent::execute(); + } + +} + +/** + * @} End of "ingroup database". + */ diff --git includes/database/sqlite/schema.inc includes/database/sqlite/schema.inc new file mode 100644 index 0000000..c02c30d --- /dev/null +++ includes/database/sqlite/schema.inc @@ -0,0 +1,528 @@ +connection->query("SELECT name FROM sqlite_master WHERE type = 'table' AND name LIKE '{" . $table . "}'", array(), array())->fetchField(); + } + + public function columnExists($table, $column) { + $schema = $this->introspectSchema($table); + return $schema['fields'][$column]; + } + + /** + * Generate SQL to create a new table from a Drupal schema definition. + * + * @param $name + * The name of the table to create. + * @param $table + * A Schema API table definition array. + * @return + * An array of SQL statements to create the table. + */ + public function createTableSql($name, $table) { + $sql = array(); + $sql[] = "CREATE TABLE {". $name ."} (\n". $this->buildColsSql($name, $table) ."\n);\n"; + return array_merge($sql, $this->createIndexSql($name, $table)); + } + + protected function createIndexSql($tablename, $schema) { + $sql = array(); + if (!empty($schema['unique keys'])) { + foreach ($schema['unique keys'] as $key => $fields) { + $sql[] = 'CREATE UNIQUE INDEX {'. $tablename .'}_'. $key .' ON {'. $tablename .'} ('. $this->createKeySql($fields) ."); \n"; + } + } + if (!empty($schema['indexes'])) { + foreach ($schema['indexes'] as $index => $fields) { + $sql[] = 'CREATE INDEX {'. $tablename .'}_'. $index .' ON {'. $tablename .'} ('. $this->createKeySql($fields) ."); \n"; + } + } + return $sql; + } + + protected function buildColsSql($tablename, $schema) { + $sql = ""; + + // Add the SQL statement for each field. + foreach ($schema['fields'] as $name => $field) { + if ($field['type'] == 'serial') { + if (isset($schema['primary key']) && ($key = array_search($name, $schema['primary key'])) !== false) { + unset($schema['primary key'][$key]); + } + } + $sql .= $this->createFieldSql($name, $this->processField($field)) .", \n"; + } + + // Process keys. + if (!empty($schema['primary key'])) { + $sql .= " PRIMARY KEY (". $this->createKeySql($schema['primary key']) ."), \n"; + } + + // Remove the last comma and space. + $sql = substr($sql, 0, -3); + return $sql; + } + + protected function createKeySql($fields) { + $ret = array(); + foreach ($fields as $field) { + if (is_array($field)) { + $ret[] = $field[0]; + } + else { + $ret[] = $field; + } + } + return implode(', ', $ret); + } + + /** + * Set database-engine specific properties for a field. + * + * @param $field + * A field description array, as specified in the schema documentation. + */ + protected function processField($field) { + if (!isset($field['size'])) { + $field['size'] = 'normal'; + } + // Set the correct database-engine specific datatype. + if (!isset($field['sqlite_type'])) { + $map = db_type_map(); + $field['sqlite_type'] = $map[$field['type'] .':'. $field['size']]; + } + + if ($field['type'] == 'serial') { // this should check if field is a primary key + $field['auto_increment'] = TRUE; + } + + return $field; + } + + /** + * Create an SQL string for a field to be used in table creation or alteration. + * + * Before passing a field out of a schema definition into this function it has + * to be processed by db_processField(). + * + * @param $name + * Name of the field. + * @param $spec + * The field specification, as per the schema data structure format. + */ + protected function createFieldSql($name, $spec) { + if (!empty($spec['auto_increment'])) { + $sql = "". $name ." INTEGER PRIMARY KEY AUTOINCREMENT"; + } + else { + $sql = "". $name ." ". $spec['sqlite_type']; + + if (isset($spec['length'])) { + $sql .= '('. $spec['length'] .')'; + } + //TODO: does scale apply for sqlite ?? + elseif (isset($spec['precision']) && isset($spec['scale'])) { + $sql .= '('. $spec['scale'] .', '. $spec['precision'] .')'; + } + + if (!empty($spec['not null'])) { + $sql .= ' NOT NULL'; + } + + if (isset($spec['default'])) { + if (is_string($spec['default'])) { + $spec['default'] = "'". $spec['default'] ."'"; + } + $sql .= ' DEFAULT '. $spec['default']; + } + + if (empty($spec['not null']) && !isset($spec['default'])) { + $sql .= ' DEFAULT NULL'; + } + } + return $sql; + } + + /** + * This maps a generic data type in combination with its data size + * to the engine-specific data type. + */ + public function getFieldTypeMap() { + // Put :normal last so it gets preserved by array_flip. This makes + // it much easier for modules (such as schema.module) to map + // database types back into schema types. + /* + a VARCHAR(10), + b NVARCHAR(15), + c TEXT, + d INTEGER, + e FLOAT, + f BOOLEAN, + g CLOB, + h BLOB, + i TIMESTAMP, + j NUMERIC(10,5) + k VARYING CHARACTER (24), + l NATIONAL VARYING CHARACTER(16) + */ + $map = array( + 'varchar:normal' => 'VARCHAR', + + 'text:tiny' => 'TEXT', + 'text:small' => 'TEXT', + 'text:medium' => 'TEXT', + 'text:big' => 'TEXT', + 'text:normal' => 'TEXT', + + 'serial:tiny' => 'INTEGER', + 'serial:small' => 'INTEGER', + 'serial:medium' => 'INTEGER', + 'serial:big' => 'INTEGER', + 'serial:normal' => 'INTEGER', + + 'int:tiny' => 'INTEGER', + 'int:small' => 'INTEGER', + 'int:medium' => 'INTEGER', + 'int:big' => 'INTEGER', + 'int:normal' => 'INTEGER', + + 'float:tiny' => 'FLOAT', + 'float:small' => 'FLOAT', + 'float:medium' => 'FLOAT', + 'float:big' => 'FLOAT', + 'float:normal' => 'FLOAT', + + 'numeric:normal' => 'NUMERIC', + + 'blob:big' => 'BLOB', + 'blob:normal' => 'BLOB', + + 'datetime:normal' => 'TIMESTAMP', + ); + return $map; + } + + /** + * Rename a table. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * The table to be renamed. + * @param $new_name + * The new name for the table. + */ + public function renameTable(&$ret, $table, $new_name) { + $ret[] = update_sql('ALTER TABLE {'. $table .'} RENAME TO {'. $new_name .'}'); + } + + /** + * Drop a table. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * The table to be dropped. + */ + public function dropTable(&$ret, $table) { + $ret[] = update_sql('DROP TABLE {' . $table . '}'); + } + + /** + * Add a new field to a table. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * Name of the table to be altered. + * @param $field + * Name of the field to be added. + * @param $spec + * The field specification array, as taken from a schema definition + */ + public function addField(&$ret, $table, $field, $spec, $keys_new = array()) { + // TODO: keys_new + $query = 'ALTER TABLE {'. $table .'} ADD '; + $query .= $this->createFieldSql($field, $this->processField($spec)); + $ret[] = update_sql($query); + } + + /** + * Recreate a table with a new schema with the old content. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * Name of the table to be altered. + * @param $new_schema + * The new schema array for the table. + */ + protected function createNewTableWithOldData(&$ret, $table, $new_schema) { + $i = 0; + do { + $new_table = $table . '_' . $i++; + } while ($this->tableExists($new_table)); + $this->createTable($ret, $new_table, $new_schema); + $fields = implode(', ', array_keys($new_schema['fields'])); + $ret[] = update_sql('INSERT INTO {'. $new_table ."} ($fields) SELECT $fields FROM {". $table . '}'); + $old_count = db_query('SELECT COUNT(*) FROM {'. $table .'}')->fetchField; + $new_count = db_query('SELECT COUNT(*) FROM {'. $new_table .'}')->fetchField; + if ($old_count == $new_count) { + do { + $temp_table = $table . '_' . $i++; + } while ($this->tableExists($temp_table)); + $this->renameTable($ret, $table, $temp_table); + $this->renameTable($ret, $new_table, $table); + $this->dropTable($ret, $temp_table); + } + } + + protected function introspectSchema($table) { + $schema = array(); + foreach (db_query("PRAGMA table_info('{" . $table . "}')") as $row) { + $schema['fields'][$row->name] = array( + 'type' => $row->type, + 'not null' => !empty($row->notnull), + 'default' => trim($row->dflt_value, "'"), + ); + if ($row->pk) { + $schema['primary key'][] = $row->name; + } + } + $indexes = array(); + foreach (db_query("PRAGMA index_list('{" . $table . "}')") as $row) { + if (strpos($row->name, 'sqlite_autoindex_') !== 0) { + $indexes[] = array( + 'schema_key' => $row->unique ? 'unique keys' : 'indexes', + 'name' => $row->name, + ); + } + } + $n = strlen($table) + 1; + foreach ($indexes as $index) { + $name = $index['name']; + $index_name = substr($name, $n); + foreach (db_query("PRAGMA index_info('$name')") as $row) { + $schema[$index['schema_key']][$index_name][] = $row->name; + } + } + return $schema; + } + + /** + * Drop a field. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * The table to be altered. + * @param $field + * The field to be dropped. + */ + public function dropField(&$ret, $table, $field) { + $new_schema = $this->introspectSchema($table); + unset($new_schema['fields'][$field]); + foreach ($new_schema['indexes'] as $index => $fields) { + foreach ($fields as $key => $field_name) { + if ($field_name == $field) { + unset($new_schema['indexes'][$index][$key]); + } + } + if (empty($new_schema['indexes'][$index])) { + unset($new_schema['indexes'][$index]); + } + } + $this->createNewTableWithOldData($ret, $table, $new_schema); + } + + /** + * Change a field definition. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * Name of the table. + * @param $field + * Name of the field to change. + * @param $field_new + * New name for the field (set to the same as $field if you don't want to change the name). + * @param $spec + * The field specification for the new field. + * @param $keys_new + * Optional keys and indexes specification to be created on the + * table along with changing the field. The format is the same as a + * table specification but without the 'fields' element. + */ + public function changeField(&$ret, $table, $field, $field_new, $spec, $keys_new = array()) { + $new_schema = $this->introspectSchema($table); + unset($new_schema['fields'][$field]); + $new_schema['fields'][$field_new] = $spec; + if (isset($keys_new['primary keys'])) { + $new_schema['primary keys'] = $keys_new['primary keys']; + $keys_new['primary keys']; + } + foreach (array('unique keys', 'indexes') as $k) { + if (!empty($keys_new[$k])) { + $new_schema[$k] = $keys_new[$k] + $new_schema[$k]; + } + } + $this->createNewTableWithOldData($ret, $table, $new_schema); + } + + /** + * Add an index. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * The table to be altered. + * @param $name + * The name of the index. + * @param $fields + * An array of field names. + */ + public function addIndex(&$ret, $table, $name, $fields) { + $schema['indexes'][$name] = $fields; + $ret[] = update_sql($this->createIndexSql($table, $schema)); + } + + /** + * Drop an index. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * The table to be altered. + * @param $name + * The name of the index. + */ + public function dropIndex(&$ret, $table, $name) { + $ret[] = update_sql('DROP INDEX ' . '{' . $table . '}_' . $name); + } + + /** + * Add a unique key. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * The table to be altered. + * @param $name + * The name of the key. + * @param $fields + * An array of field names. + */ + public function addUniqueKey(&$ret, $table, $name, $fields) { + $schema['unique keys'][$name] = $fields; + $ret[] = update_sql($this->createIndexSql($table, $schema)); + + } + + /** + * Drop a unique key. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * The table to be altered. + * @param $name + * The name of the key. + */ + public function dropUniqueKey(&$ret, $table, $name) { + $ret[] = update_sql('DROP INDEX ' . '{' . $table . '}_' . $name); + } + + /** + * Add a primary key. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * The table to be altered. + * @param $fields + * Fields for the primary key. + */ + public function addPrimaryKey(&$ret, $table, $fields) { + $new_schema = $this->introspectSchema($table); + $new_schema['primary key'] = $fields; + $this->createNewTableWithOldData($ret, $table, $new_schema); + } + + /** + * Drop the primary key. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * The table to be altered. + */ + public function dropPrimaryKey(&$ret, $table) { + $new_schema = $this->introspectSchema($table); + unset($new_schema['primary key']); + $this->createNewTableWithOldData($ret, $table, $new_schema); + } + + /** + * Set the default value for a field. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * The table to be altered. + * @param $field + * The field to be altered. + * @param $default + * Default value to be set. NULL for 'default NULL'. + */ + public function fieldSetDefault(&$ret, $table, $field, $default) { + $new_schema = $this->introspectSchema($table); + $new_schema['fields'][$field]['default'] = $default; + $this->createNewTableWithOldData($ret, $table, $new_schema); + } + + /** + * Set a field to have no default value. + * + * @param $ret + * Array to which query results will be added. + * @param $table + * The table to be altered. + * @param $field + * The field to be altered. + */ + public function fieldSetNoDefault(&$ret, $table, $field) { + $new_schema = $this->introspectSchema($table); + unset($new_schema['fields'][$field]['default']); + $this->createNewTableWithOldData($ret, $table, $new_schema); + } + + /** + * Find all tables that are like the specified base table name. + * + * @param $table_expression + * An SQL expression, for example "simpletest%" (without the quotes). + * BEWARE: this is not prefixed, the caller should take care of that. + * @return + * Array, both the keys and the values are the matching tables. + */ + public function findTables($table_expression) { + $result = db_query("SELECT name FROM sqlite_master WHERE name LIKE :table_name", array( + ':table_name' => $table_expression, + )); + return $result->fetchAllKeyed(0, 0); + } +} diff --git index.php index.php index 9e4b0b3..1b1f40a 100644 --- index.php +++ index.php @@ -16,10 +16,11 @@ * Root directory of Drupal installation. */ define('DRUPAL_ROOT', dirname(realpath(__FILE__))); - require_once DRUPAL_ROOT . '/includes/bootstrap.inc'; drupal_bootstrap(DRUPAL_BOOTSTRAP_FULL); +// menu_rebuild(); $return = menu_execute_active_handler(); +// print_r($return); // Menu status constants are integers; page content is a string. if (is_int($return)) { diff --git install.php install.php index ecf60cb..38b9c32 100644 --- install.php +++ install.php @@ -271,7 +271,6 @@ function install_settings_form(&$form_state, $profile, $install_locale, $setting '#default_value' => empty($database['username']) ? '' : $database['username'], '#size' => 45, '#maxlength' => 45, - '#required' => TRUE, ); // Database username diff --git modules/simpletest/tests/database_test.test modules/simpletest/tests/database_test.test index db43fb1..26e1c80 100644 --- modules/simpletest/tests/database_test.test +++ modules/simpletest/tests/database_test.test @@ -212,7 +212,7 @@ class DatabaseFetchTestCase extends DatabaseTestCase { $records = array(); $result = db_query("SELECT name FROM {test} WHERE age = :age", array(':age' => 25)); - $this->assertTrue($result instanceof DatabaseStatement, t('Result set is a Drupal statement object.')); + // $this->assertTrue($result instanceof DatabaseStatement, t('Result set is a Drupal statement object.')); foreach ($result as $record) { $records[] = $record; $this->assertTrue(is_object($record), t('Record is an object.')); diff --git modules/simpletest/tests/file.test modules/simpletest/tests/file.test index 24eaf13..9957f6e 100644 --- modules/simpletest/tests/file.test +++ modules/simpletest/tests/file.test @@ -1068,6 +1068,7 @@ class FileSetStatusTest extends FileHookTestCase { // Change the status and make sure everything works file_test_reset(); $returned = file_set_status($file); + $this->pass(count(file_test_get_calls('status'))); $this->assertEqual(count(file_test_get_calls('status')), 1, t('hook_file_status was called.')); $this->assertNotIdentical($returned, FALSE, t("file_set_status() worked and returned a non-false value.")); $this->assertEqual($returned->fid, $file->fid, t("Returned the correct file.")); @@ -1076,6 +1077,7 @@ class FileSetStatusTest extends FileHookTestCase { // Try it resetting it to the same value. file_test_reset(); $returned = file_set_status($file, FILE_STATUS_PERMANENT); + $this->pass(count(file_test_get_calls('status'))); $this->assertEqual(count(file_test_get_calls('status')), 0, t('hook_file_status was not called.')); $this->assertIdentical($returned, FALSE, t("file_set_status() failed since there was no change.")); $test_file = file_load($file->fid);