mirror_php/moodle
1
0
Fork 0
mirror of https://github.com/moodle/moodle.git synced 2025-04-21 00:12:56 +02:00
Code Issues Projects Releases Wiki Activity

MDL-84265 core: Remove sqlite support

Browse Source
This commit is contained in:
Andrew Nicols 2025-01-21 10:09:08 +08:00
parent 5670447ece
commit 61534718fe
No known key found for this signature in database
GPG Key ID: 6D1E3157C8CFBF14
9 changed files with 7 additions and 875 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
admin/tool/dbtransfer/locallib.php
View File

@ -141,11 +141,6 @@ function tool_dbtransfer_get_drivers() {
$dbtype = $matches[1];
$dblibrary = $matches[2];
if ($dbtype === 'sqlite3') {
// The sqlite3 driver is not fully working yet and should not be returned.
continue;
}
$targetdb = moodle_database::get_driver_instance($dbtype, $dblibrary, false);
if ($targetdb->driver_installed() !== true) {
continue;

1
lang/en/deprecated.txt
View File

@ -163,3 +163,4 @@ imagecaption_help,core_badges
issuername_help,core_badges
language_help,core_badges
version_help,core_badges
sqliteextensionisnotpresentinphp,core_install

4
lang/en/install.php
View File

@ -214,7 +214,6 @@ $string['sessionautostarterror'] = 'This should be off';
$string['sessionautostarthelp'] = '<p>Moodle requires session support and will not function without it.</p>
<p>Sessions can be enabled in the php.ini file ... look for the session.auto_start parameter.</p>';
$string['sqliteextensionisnotpresentinphp'] = 'PHP has not been properly configured with the SQLite extension. Please check your php.ini file or recompile PHP.';
$string['upgradingqtypeplugin'] = 'Upgrading question/type plugin';
$string['welcomep10'] = '{$a->installername} ({$a->installerversion})';
$string['welcomep20'] = 'You are seeing this page because you have successfully installed and
@ -229,3 +228,6 @@ $string['welcomep60'] = 'The following pages will lead you through some easy to
$string['welcomep70'] = 'Click the "Next" button below to continue with the set up of <strong>Moodle</strong>.';
$string['wwwroot'] = 'Web address';
$string['wwwrooterror'] = 'The \'Web Address\' does not appear to be valid - this Moodle installation doesn\'t appear to be there. The value below has been reset.';
// Deprecated since Moodle 5.0.
$string['sqliteextensionisnotpresentinphp'] = 'PHP has not been properly configured with the SQLite extension. Please check your php.ini file or recompile PHP.';

7
lib/classes/context.php
View File

@ -431,12 +431,7 @@ abstract class context extends stdClass implements IteratorAggregate {
FROM {context_temp} temp
WHERE temp.id={context}.id";
} else {
// Sqlite and others.
$updatesql = "UPDATE {context}
SET path = (SELECT path FROM {context_temp} WHERE id = {context}.id),
depth = (SELECT depth FROM {context_temp} WHERE id = {context}.id),
locked = (SELECT locked FROM {context_temp} WHERE id = {context}.id)
WHERE id IN (SELECT id FROM {context_temp})";
throw new \core\exception\coding_exception("Unsupported database family: {$dbfamily}");
}
$DB->execute($updatesql);

463
lib/ddl/sqlite_sql_generator.php
View File

@ -1,463 +0,0 @@
<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
* Experimental SQLite specific SQL code generator.
*
* @package core_ddl
* @copyright 2008 Andrei Bautu
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die();
require_once($CFG->libdir.'/ddl/sql_generator.php');
/// This class generate SQL code to be used against SQLite
/// It extends XMLDBgenerator so everything can be
/// overridden as needed to generate correct SQL.
class sqlite_sql_generator extends sql_generator {
/// Only set values that are different from the defaults present in XMLDBgenerator
/** @var bool To specify if the generator must use some DEFAULT clause to drop defaults.*/
public $drop_default_value_required = true;
/** @var string The DEFAULT clause required to drop defaults.*/
public $drop_default_value = NULL;
/** @var string Template to drop PKs. 'TABLENAME' and 'KEYNAME' will be replaced from this template.*/
public $drop_primary_key = 'ALTER TABLE TABLENAME DROP PRIMARY KEY';
/** @var string Template to drop UKs. 'TABLENAME' and 'KEYNAME' will be replaced from this template.*/
public $drop_unique_key = 'ALTER TABLE TABLENAME DROP KEY KEYNAME';
/** @var string Template to drop FKs. 'TABLENAME' and 'KEYNAME' will be replaced from this template.*/
public $drop_foreign_key = 'ALTER TABLE TABLENAME DROP FOREIGN KEY KEYNAME';
/** @var string To define the default to set for NOT NULLs CHARs without default (null=do nothing).*/
public $default_for_char = '';
/** @var bool To avoid outputting the rest of the field specs, leaving only the name and the sequence_name returned.*/
public $sequence_only = true;
/** @var bool True if the generator needs to add extra code to generate the sequence fields.*/
public $sequence_extra_code = false;
/** @var string The particular name for inline sequences in this generator.*/
public $sequence_name = 'INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL';
/** @var string SQL sentence to drop one index where 'TABLENAME', 'INDEXNAME' keywords are dynamically replaced.*/
public $drop_index_sql = 'ALTER TABLE TABLENAME DROP INDEX INDEXNAME';
/** @var string SQL sentence to rename one index where 'TABLENAME', 'OLDINDEXNAME' and 'NEWINDEXNAME' are dynamically replaced.*/
public $rename_index_sql = null;
/** @var string SQL sentence to rename one key 'TABLENAME', 'OLDKEYNAME' and 'NEWKEYNAME' are dynamically replaced.*/
public $rename_key_sql = null;
/**
* Creates one new XMLDBmysql
*/
public function __construct($mdb) {
parent::__construct($mdb);
}
/**
* Reset a sequence to the id field of a table.
*
* @param xmldb_table|string $table name of table or the table object.
* @return array of sql statements
*/
public function getResetSequenceSQL($table) {
if ($table instanceof xmldb_table) {
$table = $table->getName();
}
// From http://sqlite.org/autoinc.html
$value = (int)$this->mdb->get_field_sql('SELECT MAX(id) FROM {'.$table.'}');
return array("UPDATE sqlite_sequence SET seq=$value WHERE name='{$this->prefix}{$table}'");
}
/**
* Given one correct xmldb_key, returns its specs
*/
public function getKeySQL($xmldb_table, $xmldb_key) {
$key = '';
switch ($xmldb_key->getType()) {
case XMLDB_KEY_PRIMARY:
if ($this->primary_keys && count($xmldb_key->getFields())>1) {
if ($this->primary_key_name !== null) {
$key = $this->getEncQuoted($this->primary_key_name);
} else {
$key = $this->getNameForObject($xmldb_table->getName(), implode(', ', $xmldb_key->getFields()), 'pk');
}
$key .= ' PRIMARY KEY (' . implode(', ', $this->getEncQuoted($xmldb_key->getFields())) . ')';
}
break;
case XMLDB_KEY_UNIQUE:
if ($this->unique_keys) {
$key = $this->getNameForObject($xmldb_table->getName(), implode(', ', $xmldb_key->getFields()), 'uk');
$key .= ' UNIQUE (' . implode(', ', $this->getEncQuoted($xmldb_key->getFields())) . ')';
}
break;
case XMLDB_KEY_FOREIGN:
case XMLDB_KEY_FOREIGN_UNIQUE:
if ($this->foreign_keys) {
$key = $this->getNameForObject($xmldb_table->getName(), implode(', ', $xmldb_key->getFields()), 'fk');
$key .= ' FOREIGN KEY (' . implode(', ', $this->getEncQuoted($xmldb_key->getFields())) . ')';
$key .= ' REFERENCES ' . $this->getEncQuoted($this->prefix . $xmldb_key->getRefTable());
$key .= ' (' . implode(', ', $this->getEncQuoted($xmldb_key->getRefFields())) . ')';
}
break;
}
return $key;
}
/**
* Given one XMLDB Type, length and decimals, returns the DB proper SQL type.
*
* @param int $xmldb_type The xmldb_type defined constant. XMLDB_TYPE_INTEGER and other XMLDB_TYPE_* constants.
* @param int $xmldb_length The length of that data type.
* @param int $xmldb_decimals The decimal places of precision of the data type.
* @return string The DB defined data type.
*/
public function getTypeSQL($xmldb_type, $xmldb_length=null, $xmldb_decimals=null) {
switch ($xmldb_type) {
case XMLDB_TYPE_INTEGER: // From http://www.sqlite.org/datatype3.html
if (empty($xmldb_length)) {
$xmldb_length = 10;
}
$dbtype = 'INTEGER(' . $xmldb_length . ')';
break;
case XMLDB_TYPE_NUMBER:
$dbtype = $this->number_type;
if (!empty($xmldb_length)) {
$dbtype .= '(' . $xmldb_length;
if (!empty($xmldb_decimals)) {
$dbtype .= ',' . $xmldb_decimals;
}
$dbtype .= ')';
}
break;
case XMLDB_TYPE_FLOAT:
$dbtype = 'REAL';
if (!empty($xmldb_length)) {
$dbtype .= '(' . $xmldb_length;
if (!empty($xmldb_decimals)) {
$dbtype .= ',' . $xmldb_decimals;
}
$dbtype .= ')';
}
break;
case XMLDB_TYPE_CHAR:
$dbtype = 'VARCHAR';
if (empty($xmldb_length)) {
$xmldb_length='255';
}
$dbtype .= '(' . $xmldb_length . ')';
break;
case XMLDB_TYPE_BINARY:
$dbtype = 'BLOB';
break;
case XMLDB_TYPE_DATETIME:
$dbtype = 'DATETIME';
default:
case XMLDB_TYPE_TEXT:
$dbtype = 'TEXT';
break;
}
return $dbtype;
}
/**
* Function to emulate full ALTER TABLE which SQLite does not support.
* The function can be used to drop a column ($xmldb_delete_field != null and
* $xmldb_add_field == null), add a column ($xmldb_delete_field == null and
* $xmldb_add_field != null), change/rename a column ($xmldb_delete_field == null
* and $xmldb_add_field == null).
* @param xmldb_table $xmldb_table table to change
* @param xmldb_field $xmldb_add_field column to create/modify (full specification is required)
* @param xmldb_field $xmldb_delete_field column to delete/modify (only name field is required)
* @return array of strings (SQL statements to alter the table structure)
*/
protected function getAlterTableSchema($xmldb_table, $xmldb_add_field=NULL, $xmldb_delete_field=NULL) {
/// Get the quoted name of the table and field
$tablename = $this->getTableName($xmldb_table);
$oldname = $xmldb_delete_field ? $xmldb_delete_field->getName() : NULL;
$newname = $xmldb_add_field ? $xmldb_add_field->getName() : NULL;
if($xmldb_delete_field) {
$xmldb_table->deleteField($oldname);
}
if($xmldb_add_field) {
$xmldb_table->addField($xmldb_add_field);
}
if($oldname) {
// alter indexes
$indexes = $xmldb_table->getIndexes();
foreach($indexes as $index) {
$fields = $index->getFields();
$i = array_search($oldname, $fields);
if($i!==FALSE) {
if($newname) {
$fields[$i] = $newname;
} else {
unset($fields[$i]);
}
$xmldb_table->deleteIndex($index->getName());
if(count($fields)) {
$index->setFields($fields);
$xmldb_table->addIndex($index);
}
}
}
// alter keys
$keys = $xmldb_table->getKeys();
foreach($keys as $key) {
$fields = $key->getFields();
$reffields = $key->getRefFields();
$i = array_search($oldname, $fields);
if($i!==FALSE) {
if($newname) {
$fields[$i] = $newname;
} else {
unset($fields[$i]);
unset($reffields[$i]);
}
$xmldb_table->deleteKey($key->getName());
if(count($fields)) {
$key->setFields($fields);
$key->setRefFields($fields);
$xmldb_table->addkey($key);
}
}
}
}
// prepare data copy
$fields = $xmldb_table->getFields();
foreach ($fields as $key => $field) {
$fieldname = $field->getName();
if($fieldname == $newname && $oldname && $oldname != $newname) {
// field rename operation
$fields[$key] = $this->getEncQuoted($oldname) . ' AS ' . $this->getEncQuoted($newname);
} else {
$fields[$key] = $this->getEncQuoted($field->getName());
}
}
$fields = implode(',', $fields);
$results[] = 'BEGIN TRANSACTION';
$results[] = 'CREATE TEMPORARY TABLE temp_data AS SELECT * FROM ' . $tablename;
$results[] = 'DROP TABLE ' . $tablename;
$results = array_merge($results, $this->getCreateTableSQL($xmldb_table));
$results[] = 'INSERT INTO ' . $tablename . ' SELECT ' . $fields . ' FROM temp_data';
$results[] = 'DROP TABLE temp_data';
$results[] = 'COMMIT';
return $results;
}
/**
* Given one xmldb_table and one xmldb_field, return the SQL statements needed to alter the field in the table.
*
* @param xmldb_table $xmldb_table The table related to $xmldb_field.
* @param xmldb_field $xmldb_field The instance of xmldb_field to create the SQL from.
* @param string $skip_type_clause The type clause on alter columns, NULL by default.
* @param string $skip_default_clause The default clause on alter columns, NULL by default.
* @param string $skip_notnull_clause The null/notnull clause on alter columns, NULL by default.
* @return string The field altering SQL statement.
*/
public function getAlterFieldSQL($xmldb_table, $xmldb_field, $skip_type_clause = NULL, $skip_default_clause = NULL, $skip_notnull_clause = NULL) {
return $this->getAlterTableSchema($xmldb_table, $xmldb_field, $xmldb_field);
}
/**
* Given one xmldb_table and one xmldb_key, return the SQL statements needed to add the key to the table
* note that underlying indexes will be added as parametrised by $xxxx_keys and $xxxx_index parameters
*/
public function getAddKeySQL($xmldb_table, $xmldb_key) {
$xmldb_table->addKey($xmldb_key);
return $this->getAlterTableSchema($xmldb_table);
}
/**
* Given one xmldb_table and one xmldb_field, return the SQL statements needed to add its default
* (usually invoked from getModifyDefaultSQL()
*
* @param xmldb_table $xmldb_table The xmldb_table object instance.
* @param xmldb_field $xmldb_field The xmldb_field object instance.
* @return array Array of SQL statements to create a field's default.
*/
public function getCreateDefaultSQL($xmldb_table, $xmldb_field) {
return $this->getAlterTableSchema($xmldb_table, $xmldb_field, $xmldb_field);
}
/**
* Given one correct xmldb_field and the new name, returns the SQL statements
* to rename it (inside one array).
*
* @param xmldb_table $xmldb_table The table related to $xmldb_field.
* @param xmldb_field $xmldb_field The instance of xmldb_field to get the renamed field from.
* @param string $newname The new name to rename the field to.
* @return array The SQL statements for renaming the field.
*/
public function getRenameFieldSQL($xmldb_table, $xmldb_field, $newname) {
$oldfield = clone($xmldb_field);
$xmldb_field->setName($newname);
return $this->getAlterTableSchema($xmldb_table, $xmldb_field, $oldfield);
}
/**
* Given one xmldb_table and one xmldb_index, return the SQL statements needed to rename the index in the table
*/
function getRenameIndexSQL($xmldb_table, $xmldb_index, $newname) {
/// Get the real index name
$dbindexname = $this->mdb->get_manager()->find_index_name($xmldb_table, $xmldb_index);
$xmldb_index->setName($newname);
$results = array('DROP INDEX ' . $dbindexname);
$results = array_merge($results, $this->getCreateIndexSQL($xmldb_table, $xmldb_index));
return $results;
}
/**
* Given one xmldb_table and one xmldb_key, return the SQL statements needed to rename the key in the table
* Experimental! Shouldn't be used at all!
*/
public function getRenameKeySQL($xmldb_table, $xmldb_key, $newname) {
$xmldb_table->deleteKey($xmldb_key->getName());
$xmldb_key->setName($newname);
$xmldb_table->addkey($xmldb_key);
return $this->getAlterTableSchema($xmldb_table);
}
/**
* Given one xmldb_table and one xmldb_field, return the SQL statements needed to drop the field from the table.
*
* @param xmldb_table $xmldb_table The table related to $xmldb_field.
* @param xmldb_field $xmldb_field The instance of xmldb_field to create the SQL from.
* @return array The SQL statement for dropping a field from the table.
*/
public function getDropFieldSQL($xmldb_table, $xmldb_field) {
return $this->getAlterTableSchema($xmldb_table, NULL, $xmldb_field);
}
/**
* Given one xmldb_table and one xmldb_index, return the SQL statements needed to drop the index from the table
*/
public function getDropIndexSQL($xmldb_table, $xmldb_index) {
$xmldb_table->deleteIndex($xmldb_index->getName());
return $this->getAlterTableSchema($xmldb_table);
}
/**
* Given one xmldb_table and one xmldb_index, return the SQL statements needed to drop the index from the table
*/
public function getDropKeySQL($xmldb_table, $xmldb_key) {
$xmldb_table->deleteKey($xmldb_key->getName());
return $this->getAlterTableSchema($xmldb_table);
}
/**
* Given one xmldb_table and one xmldb_field, return the SQL statements needed to drop its default
* (usually invoked from getModifyDefaultSQL()
*
* Note that this method may be dropped in future.
*
* @param xmldb_table $xmldb_table The xmldb_table object instance.
* @param xmldb_field $xmldb_field The xmldb_field object instance.
* @return array Array of SQL statements to create a field's default.
*
* @todo MDL-31147 Moodle 2.1 - Drop getDropDefaultSQL()
*/
public function getDropDefaultSQL($xmldb_table, $xmldb_field) {
return $this->getAlterTableSchema($xmldb_table, $xmldb_field, $xmldb_field);
}
/**
* Returns the code (array of statements) needed to add one comment to the table.
*
* @param xmldb_table $xmldb_table The xmldb_table object instance.
* @return array Array of SQL statements to add one comment to the table.
*/
function getCommentSQL($xmldb_table) {
return array();
}
/**
* Given one object name and it's type (pk, uk, fk, ck, ix, uix, seq, trg).
*
* (MySQL requires the whole xmldb_table object to be specified, so we add it always)
*
* This is invoked from getNameForObject().
* Only some DB have this implemented.
*
* @param string $object_name The object's name to check for.
* @param string $type The object's type (pk, uk, fk, ck, ix, uix, seq, trg).
* @param string $table_name The table's name to check in
* @return bool If such name is currently in use (true) or no (false)
*/
public function isNameInUse($object_name, $type, $table_name) {
// TODO: add introspection code
return false; //No name in use found
}
/**
* Returns an array of reserved words (lowercase) for this DB
* @return array An array of database specific reserved words
*/
public static function getReservedWords() {
/// From http://www.sqlite.org/lang_keywords.html
$reserved_words = array (
'add', 'all', 'alter', 'and', 'as', 'autoincrement',
'between', 'by',
'case', 'check', 'collate', 'column', 'commit', 'constraint', 'create', 'cross',
'default', 'deferrable', 'delete', 'distinct', 'drop',
'else', 'escape', 'except', 'exists',
'foreign', 'from', 'full',
'group',
'having',
'in', 'index', 'inner', 'insert', 'intersect', 'into', 'is', 'isnull',
'join',
'left', 'limit',
'natural', 'not', 'notnull', 'null',
'on', 'or', 'order', 'outer',
'primary',
'references', 'regexp', 'right', 'rollback',
'select', 'set',
'table', 'then', 'to', 'transaction',
'union', 'unique', 'update', 'using',
'values',
'when', 'where'
);
return $reserved_words;
}
/**
* Adds slashes to string.
* @param string $s
* @return string The escaped string.
*/
public function addslashes($s) {
// do not use php addslashes() because it depends on PHP quote settings!
$s = str_replace("'", "''", $s);
return $s;
}
}

9
lib/ddl/tests/ddl_test.php
View File

@ -2294,7 +2294,6 @@ final class ddl_test extends \database_driver_testcase {
break;
case 'mssql': // The Moodle connection runs under 'QUOTED_IDENTIFIER ON'.
case 'postgres':
case 'sqlite':
default:
$this->assertSame('"' . $columnname . '"', $gen->getEncQuoted($columnname));
break;
@ -2344,10 +2343,6 @@ final class ddl_test extends \database_driver_testcase {
$gen->getRenameFieldSQL($table, $field, $newcolumnname)
);
break;
case 'sqlite':
// Skip it, since the DB is not supported yet.
// BTW renaming a column name is already covered by the integration test 'testRenameField'.
break;
case 'mssql': // The Moodle connection runs under 'QUOTED_IDENTIFIER ON'.
$this->assertSame(
[ "sp_rename '{$prefix}$tablename.[$oldcolumnname]', '$newcolumnname', 'COLUMN'" ],
@ -2371,10 +2366,6 @@ final class ddl_test extends \database_driver_testcase {
$gen->getRenameFieldSQL($table, $field, $newcolumnname)
);
break;
case 'sqlite':
// Skip it, since the DB is not supported yet.
// BTW renaming a column name is already covered by the integration test 'testRenameField'.
break;
case 'mssql': // The Moodle connection runs under 'QUOTED_IDENTIFIER ON'.
$this->assertSame(
[ "sp_rename '{$prefix}$tablename.[$oldcolumnname]', '$newcolumnname', 'COLUMN'" ],

381
lib/dml/sqlite3_pdo_moodle_database.php
View File

@ -1,381 +0,0 @@
<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
* Experimental pdo database class.
*
* @package core_dml
* @copyright 2008 Andrei Bautu
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
defined('MOODLE_INTERNAL') || die();
require_once(__DIR__.'/pdo_moodle_database.php');
/**
* Experimental pdo database class
*
* @package core_dml
* @copyright 2008 Andrei Bautu
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
class sqlite3_pdo_moodle_database extends pdo_moodle_database {
protected $database_file_extension = '.sq3.php';
/**
* Detects if all needed PHP stuff installed.
* Note: can be used before connect()
* @return mixed true if ok, string if something
*/
public function driver_installed() {
if (!extension_loaded('pdo_sqlite') || !extension_loaded('pdo')){
return get_string('sqliteextensionisnotpresentinphp', 'install');
}
return true;
}
/**
* Returns database family type - describes SQL dialect
* Note: can be used before connect()
* @return string db family name (mysql, postgres, mssql, etc.)
*/
public function get_dbfamily() {
return 'sqlite';
}
/**
* Returns more specific database driver type
* Note: can be used before connect()
* @return string db type mysqli, pgsql, mssql, sqlsrv
*/
protected function get_dbtype() {
return 'sqlite3';
}
protected function configure_dbconnection() {
// try to protect database file against web access;
// this is required in case that the moodledata folder is web accessible and
// .htaccess is not in place; requires that the database file extension is php
$this->pdb->exec('CREATE TABLE IF NOT EXISTS "<?php die?>" (id int)');
$this->pdb->exec('PRAGMA synchronous=OFF');
$this->pdb->exec('PRAGMA short_column_names=1');
$this->pdb->exec('PRAGMA encoding="UTF-8"');
$this->pdb->exec('PRAGMA case_sensitive_like=0');
$this->pdb->exec('PRAGMA locking_mode=NORMAL');
}
/**
* Attempt to create the database
* @param string $dbhost
* @param string $dbuser
* @param string $dbpass
* @param string $dbname
*
* @return bool success
*/
public function create_database($dbhost, $dbuser, $dbpass, $dbname, ?array $dboptions=null) {
global $CFG;
$this->dbhost = $dbhost;
$this->dbuser = $dbuser;
$this->dbpass = $dbpass;
$this->dbname = $dbname;
$filepath = $this->get_dbfilepath();
$dirpath = dirname($filepath);
@mkdir($dirpath, $CFG->directorypermissions, true);
return touch($filepath);
}
/**
* Returns the driver-dependent DSN for PDO based on members stored by connect.
* Must be called after connect (or after $dbname, $dbhost, etc. members have been set).
* @return string driver-dependent DSN
*/
protected function get_dsn() {
return 'sqlite:'.$this->get_dbfilepath();
}
/**
* Returns the file path for the database file, computed from dbname and/or dboptions.
* If dboptions['file'] is set, then it is used (use :memory: for in memory database);
* else if dboptions['path'] is set, then the file will be <dboptions path>/<dbname>.sq3.php;
* else if dbhost is set and not localhost, then the file will be <dbhost>/<dbname>.sq3.php;
* else the file will be <moodle data path>/<dbname>.sq3.php
* @return string file path to the SQLite database;
*/
public function get_dbfilepath() {
global $CFG;
if (!empty($this->dboptions['file'])) {
return $this->dboptions['file'];
}
if ($this->dbhost && $this->dbhost != 'localhost') {
$path = $this->dbhost;
} else {
$path = $CFG->dataroot;
}
$path = rtrim($path, '\\/').'/';
if (!empty($this->dbuser)) {
$path .= $this->dbuser.'_';
}
$path .= $this->dbname.'_'.md5($this->dbpass).$this->database_file_extension;
return $path;
}
/**
* Return tables in database WITHOUT current prefix.
* @param bool $usecache if true, returns list of cached tables.
* @return array of table names in lowercase and without prefix
*/
public function get_tables($usecache=true) {
$tables = array();
$sql = 'SELECT name FROM sqlite_master WHERE type="table" UNION ALL SELECT name FROM sqlite_temp_master WHERE type="table" ORDER BY name';
if ($this->debug) {
$this->debug_query($sql);
}
$rstables = $this->pdb->query($sql);
foreach ($rstables as $table) {
$table = $table['name'];
$table = strtolower($table);
if ($this->prefix !== false && $this->prefix !== '') {
if (strpos($table, $this->prefix) !== 0) {
continue;
}
$table = substr($table, strlen($this->prefix));
}
$tables[$table] = $table;
}
return $tables;
}
/**
* Return table indexes - everything lowercased
* @param string $table The table we want to get indexes from.
* @return array of arrays
*/
public function get_indexes($table) {
$indexes = array();
$sql = 'PRAGMA index_list('.$this->prefix.$table.')';
if ($this->debug) {
$this->debug_query($sql);
}
$rsindexes = $this->pdb->query($sql);
foreach($rsindexes as $index) {
$unique = (boolean)$index['unique'];
$index = $index['name'];
$sql = 'PRAGMA index_info("'.$index.'")';
if ($this->debug) {
$this->debug_query($sql);
}
$rscolumns = $this->pdb->query($sql);
$columns = array();
foreach($rscolumns as $row) {
$columns[] = strtolower($row['name']);
}
$index = strtolower($index);
$indexes[$index]['unique'] = $unique;
$indexes[$index]['columns'] = $columns;
}
return $indexes;
}
/**
* Returns detailed information about columns in table.
*
* @param string $table name
* @return array array of database_column_info objects indexed with column names
*/
protected function fetch_columns(string $table): array {
$structure = array();
// get table's CREATE TABLE command (we'll need it for autoincrement fields)
$sql = 'SELECT sql FROM sqlite_master WHERE type="table" AND tbl_name="'.$this->prefix.$table.'"';
if ($this->debug) {
$this->debug_query($sql);
}
$createsql = $this->pdb->query($sql)->fetch();
if (!$createsql) {
return false;
}
$createsql = $createsql['sql'];
$sql = 'PRAGMA table_info("'. $this->prefix.$table.'")';
if ($this->debug) {
$this->debug_query($sql);
}
$rscolumns = $this->pdb->query($sql);
foreach ($rscolumns as $row) {
$columninfo = array(
'name' => strtolower($row['name']), // colum names must be lowercase
'not_null' =>(boolean)$row['notnull'],
'primary_key' => (boolean)$row['pk'],
'has_default' => !is_null($row['dflt_value']),
'default_value' => $row['dflt_value'],
'auto_increment' => false,
'binary' => false,
//'unsigned' => false,
);
$type = explode('(', $row['type']);
$columninfo['type'] = strtolower($type[0]);
if (count($type) > 1) {
$size = explode(',', trim($type[1], ')'));
$columninfo['max_length'] = $size[0];
if (count($size) > 1) {
$columninfo['scale'] = $size[1];
}
}
// SQLite does not have a fixed set of datatypes (ie. it accepts any string as
// datatype in the CREATE TABLE command. We try to guess which type is used here
switch(substr($columninfo['type'], 0, 3)) {
case 'int': // int integer
if ($columninfo['primary_key'] && preg_match('/'.$columninfo['name'].'\W+integer\W+primary\W+key\W+autoincrement/im', $createsql)) {
$columninfo['meta_type'] = 'R';
$columninfo['auto_increment'] = true;
} else {
$columninfo['meta_type'] = 'I';
}
break;
case 'num': // number numeric
case 'rea': // real
case 'dou': // double
case 'flo': // float
$columninfo['meta_type'] = 'N';
break;
case 'var': // varchar
case 'cha': // char
$columninfo['meta_type'] = 'C';
break;
case 'enu': // enums
$columninfo['meta_type'] = 'C';
break;
case 'tex': // text
case 'clo': // clob
$columninfo['meta_type'] = 'X';
break;
case 'blo': // blob
case 'non': // none
$columninfo['meta_type'] = 'B';
$columninfo['binary'] = true;
break;
case 'boo': // boolean
case 'bit': // bit
case 'log': // logical
$columninfo['meta_type'] = 'L';
$columninfo['max_length'] = 1;
break;
case 'tim': // timestamp
$columninfo['meta_type'] = 'T';
break;
case 'dat': // date datetime
$columninfo['meta_type'] = 'D';
break;
}
if ($columninfo['has_default'] && ($columninfo['meta_type'] == 'X' || $columninfo['meta_type']== 'C')) {
// trim extra quotes from text default values
$columninfo['default_value'] = substr($columninfo['default_value'], 1, -1);
}
$structure[$columninfo['name']] = new database_column_info($columninfo);
}
return $structure;
}
/**
* Normalise values based in RDBMS dependencies (booleans, LOBs...)
*
* @param database_column_info $column column metadata corresponding with the value we are going to normalise
* @param mixed $value value we are going to normalise
* @return mixed the normalised value
*/
protected function normalise_value($column, $value) {
return $value;
}
/**
* Returns the sql statement with clauses to append used to limit a recordset range.
* @param string $sql the SQL statement to limit.
* @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set).
* @param int $limitnum return a subset comprising this many records (optional, required if $limitfrom is set).
* @return string the SQL statement with limiting clauses
*/
protected function get_limit_clauses($sql, $limitfrom=0, $limitnum=0) {
if ($limitnum) {
$sql .= ' LIMIT '.$limitnum;
if ($limitfrom) {
$sql .= ' OFFSET '.$limitfrom;
}
}
return $sql;
}
/**
* Delete the records from a table where all the given conditions met.
* If conditions not specified, table is truncated.
*
* @param string $table the table to delete from.
* @param array $conditions optional array $fieldname=>requestedvalue with AND in between
* @return returns success.
*/
public function delete_records($table, ?array $conditions=null) {
if (is_null($conditions)) {
return $this->execute("DELETE FROM {{$table}}");
}
list($select, $params) = $this->where_clause($table, $conditions);
return $this->delete_records_select($table, $select, $params);
}
/**
* Returns the proper SQL to do CONCAT between the elements passed
* Can take many parameters
*
* @param string $elements,...
* @return string
*/
public function sql_concat(...$elements) {
return implode('||', $elements);
}
/**
* Returns the proper SQL to do CONCAT between the elements passed
* with a given separator
*
* @param string $separator
* @param array $elements
* @return string
*/
public function sql_concat_join($separator="' '", $elements=array()) {
// Intersperse $elements in the array.
// Add items to the array on the fly, walking it
// _backwards_ splicing the elements in. The loop definition
// should skip first and last positions.
for ($n=count($elements)-1; $n > 0; $n--) {
array_splice($elements, $n, 0, $separator);
}
return implode('||', $elements);
}
/**
* Returns the SQL text to be used in order to perform one bitwise XOR operation
* between 2 integers.
*
* @param integer int1 first integer in the operation
* @param integer int2 second integer in the operation
* @return string the piece of SQL code to be used in your statement.
*/
public function sql_bitxor($int1, $int2) {
return '( ~' . $this->sql_bitand($int1, $int2) . ' & ' . $this->sql_bitor($int1, $int2) . ')';
}
}

2
lib/dml/tests/dml_test.php
View File

@ -5001,7 +5001,7 @@ EOD;
$this->assertCount(1, $records);
$this->assertEquals(5, reset($records)->course);
// We have sql like this in moodle, this syntax breaks on older versions of sqlite for example..
// We have sql like this in moodle.
$sql = "SELECT a.id AS id, a.course AS course
FROM {{$tablename}} a
JOIN (SELECT * FROM {{$tablename}}) b ON a.id = b.id

10
mod/quiz/locallib.php
View File

@ -826,15 +826,7 @@ function quiz_update_open_attempts(array $conditions) {
JOIN ( $quizausersql ) quizauser ON quizauser.id = quiza.id
WHERE $attemptselect";
} else {
// Sqlite and others.
$updatesql = "UPDATE {quiz_attempts} quiza
SET timecheckstate = (
SELECT $timecheckstatesql
FROM {quiz} quiz, ( $quizausersql ) quizauser
WHERE quiz.id = quiza.quiz
AND quizauser.id = quiza.id
)
WHERE $attemptselect";
throw new \core\exception\coding_exception("Unsupported database family: {$dbfamily}");
}
$DB->execute($updatesql, $params);