c3e2e66e381842e4f8027b853c52f8ee5cd53b4e
[moodle.git] / lib / dml / mysqli_native_moodle_database.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Native mysqli class representing moodle database interface.
19  *
20  * @package    core_dml
21  * @copyright  2008 Petr Skoda (http://skodak.org)
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 defined('MOODLE_INTERNAL') || die();
27 require_once(__DIR__.'/moodle_database.php');
28 require_once(__DIR__.'/mysqli_native_moodle_recordset.php');
29 require_once(__DIR__.'/mysqli_native_moodle_temptables.php');
31 /**
32  * Native mysqli class representing moodle database interface.
33  *
34  * @package    core_dml
35  * @copyright  2008 Petr Skoda (http://skodak.org)
36  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
37  */
38 class mysqli_native_moodle_database extends moodle_database {
40     /** @var mysqli $mysqli */
41     protected $mysqli = null;
42     /** @var bool is compressed row format supported cache */
43     protected $compressedrowformatsupported = null;
45     private $transactions_supported = null;
47     /**
48      * Attempt to create the database
49      * @param string $dbhost
50      * @param string $dbuser
51      * @param string $dbpass
52      * @param string $dbname
53      * @return bool success
54      * @throws dml_exception A DML specific exception is thrown for any errors.
55      */
56     public function create_database($dbhost, $dbuser, $dbpass, $dbname, array $dboptions=null) {
57         $driverstatus = $this->driver_installed();
59         if ($driverstatus !== true) {
60             throw new dml_exception('dbdriverproblem', $driverstatus);
61         }
63         if (!empty($dboptions['dbsocket'])
64                 and (strpos($dboptions['dbsocket'], '/') !== false or strpos($dboptions['dbsocket'], '\\') !== false)) {
65             $dbsocket = $dboptions['dbsocket'];
66         } else {
67             $dbsocket = ini_get('mysqli.default_socket');
68         }
69         if (empty($dboptions['dbport'])) {
70             $dbport = (int)ini_get('mysqli.default_port');
71         } else {
72             $dbport = (int)$dboptions['dbport'];
73         }
74         // verify ini.get does not return nonsense
75         if (empty($dbport)) {
76             $dbport = 3306;
77         }
78         ob_start();
79         $conn = new mysqli($dbhost, $dbuser, $dbpass, '', $dbport, $dbsocket); // Connect without db
80         $dberr = ob_get_contents();
81         ob_end_clean();
82         $errorno = @$conn->connect_errno;
84         if ($errorno !== 0) {
85             throw new dml_connection_exception($dberr);
86         }
88         // Normally a check would be done before setting utf8mb4, but the database can be created
89         // before the enviroment checks are done. We'll proceed with creating the database and then do checks next.
90         $charset = 'utf8mb4';
91         if (isset($dboptions['dbcollation']) and (strpos($dboptions['dbcollation'], 'utf8_') === 0
92                 || strpos($dboptions['dbcollation'], 'utf8mb4_') === 0)) {
93             $collation = $dboptions['dbcollation'];
94             $collationinfo = explode('_', $dboptions['dbcollation']);
95             $charset = reset($collationinfo);
96         } else {
97             $collation = 'utf8mb4_unicode_ci';
98         }
100         $result = $conn->query("CREATE DATABASE $dbname DEFAULT CHARACTER SET $charset DEFAULT COLLATE ".$collation);
102         $conn->close();
104         if (!$result) {
105             throw new dml_exception('cannotcreatedb');
106         }
108         return true;
109     }
111     /**
112      * Detects if all needed PHP stuff installed.
113      * Note: can be used before connect()
114      * @return mixed true if ok, string if something
115      */
116     public function driver_installed() {
117         if (!extension_loaded('mysqli')) {
118             return get_string('mysqliextensionisnotpresentinphp', 'install');
119         }
120         return true;
121     }
123     /**
124      * Returns database family type - describes SQL dialect
125      * Note: can be used before connect()
126      * @return string db family name (mysql, postgres, mssql, oracle, etc.)
127      */
128     public function get_dbfamily() {
129         return 'mysql';
130     }
132     /**
133      * Returns more specific database driver type
134      * Note: can be used before connect()
135      * @return string db type mysqli, pgsql, oci, mssql, sqlsrv
136      */
137     protected function get_dbtype() {
138         return 'mysqli';
139     }
141     /**
142      * Returns general database library name
143      * Note: can be used before connect()
144      * @return string db type pdo, native
145      */
146     protected function get_dblibrary() {
147         return 'native';
148     }
150     /**
151      * Returns the current MySQL db engine.
152      *
153      * This is an ugly workaround for MySQL default engine problems,
154      * Moodle is designed to work best on ACID compliant databases
155      * with full transaction support. Do not use MyISAM.
156      *
157      * @return string or null MySQL engine name
158      */
159     public function get_dbengine() {
160         if (isset($this->dboptions['dbengine'])) {
161             return $this->dboptions['dbengine'];
162         }
164         if ($this->external) {
165             return null;
166         }
168         $engine = null;
170         // Look for current engine of our config table (the first table that gets created),
171         // so that we create all tables with the same engine.
172         $sql = "SELECT engine
173                   FROM INFORMATION_SCHEMA.TABLES
174                  WHERE table_schema = DATABASE() AND table_name = '{$this->prefix}config'";
175         $this->query_start($sql, NULL, SQL_QUERY_AUX);
176         $result = $this->mysqli->query($sql);
177         $this->query_end($result);
178         if ($rec = $result->fetch_assoc()) {
179             // MySQL 8 BC: information_schema.* returns the fields in upper case.
180             $rec = array_change_key_case($rec, CASE_LOWER);
181             $engine = $rec['engine'];
182         }
183         $result->close();
185         if ($engine) {
186             // Cache the result to improve performance.
187             $this->dboptions['dbengine'] = $engine;
188             return $engine;
189         }
191         // Get the default database engine.
192         $sql = "SELECT @@default_storage_engine engine";
193         $this->query_start($sql, NULL, SQL_QUERY_AUX);
194         $result = $this->mysqli->query($sql);
195         $this->query_end($result);
196         if ($rec = $result->fetch_assoc()) {
197             $engine = $rec['engine'];
198         }
199         $result->close();
201         if ($engine === 'MyISAM') {
202             // we really do not want MyISAM for Moodle, InnoDB or XtraDB is a reasonable defaults if supported
203             $sql = "SHOW STORAGE ENGINES";
204             $this->query_start($sql, NULL, SQL_QUERY_AUX);
205             $result = $this->mysqli->query($sql);
206             $this->query_end($result);
207             $engines = array();
208             while ($res = $result->fetch_assoc()) {
209                 if ($res['Support'] === 'YES' or $res['Support'] === 'DEFAULT') {
210                     $engines[$res['Engine']] = true;
211                 }
212             }
213             $result->close();
214             if (isset($engines['InnoDB'])) {
215                 $engine = 'InnoDB';
216             }
217             if (isset($engines['XtraDB'])) {
218                 $engine = 'XtraDB';
219             }
220         }
222         // Cache the result to improve performance.
223         $this->dboptions['dbengine'] = $engine;
224         return $engine;
225     }
227     /**
228      * Returns the current MySQL db collation.
229      *
230      * This is an ugly workaround for MySQL default collation problems.
231      *
232      * @return string or null MySQL collation name
233      */
234     public function get_dbcollation() {
235         if (isset($this->dboptions['dbcollation'])) {
236             return $this->dboptions['dbcollation'];
237         }
238         if ($this->external) {
239             return null;
240         }
242         $collation = null;
244         // Look for current collation of our config table (the first table that gets created),
245         // so that we create all tables with the same collation.
246         $sql = "SELECT collation_name
247                   FROM INFORMATION_SCHEMA.COLUMNS
248                  WHERE table_schema = DATABASE() AND table_name = '{$this->prefix}config' AND column_name = 'value'";
249         $this->query_start($sql, NULL, SQL_QUERY_AUX);
250         $result = $this->mysqli->query($sql);
251         $this->query_end($result);
252         if ($rec = $result->fetch_assoc()) {
253             // MySQL 8 BC: information_schema.* returns the fields in upper case.
254             $rec = array_change_key_case($rec, CASE_LOWER);
255             $collation = $rec['collation_name'];
256         }
257         $result->close();
260         if (!$collation) {
261             // Get the default database collation, but only if using UTF-8.
262             $sql = "SELECT @@collation_database";
263             $this->query_start($sql, NULL, SQL_QUERY_AUX);
264             $result = $this->mysqli->query($sql);
265             $this->query_end($result);
266             if ($rec = $result->fetch_assoc()) {
267                 if (strpos($rec['@@collation_database'], 'utf8_') === 0 || strpos($rec['@@collation_database'], 'utf8mb4_') === 0) {
268                     $collation = $rec['@@collation_database'];
269                 }
270             }
271             $result->close();
272         }
274         if (!$collation) {
275             // We want only utf8 compatible collations.
276             $collation = null;
277             $sql = "SHOW COLLATION WHERE Collation LIKE 'utf8mb4\_%' AND Charset = 'utf8mb4'";
278             $this->query_start($sql, NULL, SQL_QUERY_AUX);
279             $result = $this->mysqli->query($sql);
280             $this->query_end($result);
281             while ($res = $result->fetch_assoc()) {
282                 $collation = $res['Collation'];
283                 if (strtoupper($res['Default']) === 'YES') {
284                     $collation = $res['Collation'];
285                     break;
286                 }
287             }
288             $result->close();
289         }
291         // Cache the result to improve performance.
292         $this->dboptions['dbcollation'] = $collation;
293         return $collation;
294     }
296     /**
297      * Get the row format from the database schema.
298      *
299      * @param string $table
300      * @return string row_format name or null if not known or table does not exist.
301      */
302     public function get_row_format($table = null) {
303         $rowformat = null;
304         if (isset($table)) {
305             $table = $this->mysqli->real_escape_string($table);
306             $sql = "SELECT row_format
307                       FROM INFORMATION_SCHEMA.TABLES
308                      WHERE table_schema = DATABASE() AND table_name = '{$this->prefix}$table'";
309         } else {
310             if (($this->get_dbtype() == 'mysqli') &&
311                 // Breaking change in MySQL 8.0.0+: antelope file format support has been removed.
312                 version_compare($this->get_server_info()['version'], '8.0.0', '>=')) {
313                 $dbengine = $this->get_dbengine();
314                 $supporteddbengines = array('InnoDB', 'XtraDB');
315                 if (in_array($dbengine, $supporteddbengines)) {
316                     $rowformat = 'Barracuda';
317                 }
319                 return $rowformat;
320             }
322             $sql = "SHOW VARIABLES LIKE 'innodb_file_format'";
323         }
324         $this->query_start($sql, NULL, SQL_QUERY_AUX);
325         $result = $this->mysqli->query($sql);
326         $this->query_end($result);
327         if ($rec = $result->fetch_assoc()) {
328             // MySQL 8 BC: information_schema.* returns the fields in upper case.
329             $rec = array_change_key_case($rec, CASE_LOWER);
330             if (isset($table)) {
331                 $rowformat = $rec['row_format'];
332             } else {
333                 $rowformat = $rec['value'];
334             }
335         }
336         $result->close();
338         return $rowformat;
339     }
341     /**
342      * Is this database compatible with compressed row format?
343      * This feature is necessary for support of large number of text
344      * columns in InnoDB/XtraDB database.
345      *
346      * @param bool $cached use cached result
347      * @return bool true if table can be created or changed to compressed row format.
348      */
349     public function is_compressed_row_format_supported($cached = true) {
350         if ($cached and isset($this->compressedrowformatsupported)) {
351             return($this->compressedrowformatsupported);
352         }
354         $engine = strtolower($this->get_dbengine());
355         $info = $this->get_server_info();
357         if (version_compare($info['version'], '5.5.0') < 0) {
358             // MySQL 5.1 is not supported here because we cannot read the file format.
359             $this->compressedrowformatsupported = false;
361         } else if ($engine !== 'innodb' and $engine !== 'xtradb') {
362             // Other engines are not supported, most probably not compatible.
363             $this->compressedrowformatsupported = false;
365         } else if (!$this->is_file_per_table_enabled()) {
366             $this->compressedrowformatsupported = false;
368         } else if ($this->get_row_format() !== 'Barracuda') {
369             $this->compressedrowformatsupported = false;
371         } else {
372             // All the tests passed, we can safely use ROW_FORMAT=Compressed in sql statements.
373             $this->compressedrowformatsupported = true;
374         }
376         return $this->compressedrowformatsupported;
377     }
379     /**
380      * Check the database to see if innodb_file_per_table is on.
381      *
382      * @return bool True if on otherwise false.
383      */
384     public function is_file_per_table_enabled() {
385         if ($filepertable = $this->get_record_sql("SHOW VARIABLES LIKE 'innodb_file_per_table'")) {
386             if ($filepertable->value == 'ON') {
387                 return true;
388             }
389         }
390         return false;
391     }
393     /**
394      * Check the database to see if innodb_large_prefix is on.
395      *
396      * @return bool True if on otherwise false.
397      */
398     public function is_large_prefix_enabled() {
399         if (($this->get_dbtype() == 'mysqli') &&
400             // Breaking change since 8.0.0: there is only one file format and 'innodb_large_prefix' has been removed.
401             version_compare($this->get_server_info()['version'], '8.0.0', '>=')) {
402             return true;
403         }
405         if ($largeprefix = $this->get_record_sql("SHOW VARIABLES LIKE 'innodb_large_prefix'")) {
406             if ($largeprefix->value == 'ON') {
407                 return true;
408             }
409         }
410         return false;
411     }
413     /**
414      * Determine if the row format should be set to compressed, dynamic, or default.
415      *
416      * Terrible kludge. If we're using utf8mb4 AND we're using InnoDB, we need to specify row format to
417      * be either dynamic or compressed (default is compact) in order to allow for bigger indexes (MySQL
418      * errors #1709 and #1071).
419      *
420      * @param  string $engine The database engine being used. Will be looked up if not supplied.
421      * @param  string $collation The database collation to use. Will look up the current collation if not supplied.
422      * @return string An sql fragment to add to sql statements.
423      */
424     public function get_row_format_sql($engine = null, $collation = null) {
426         if (!isset($engine)) {
427             $engine = $this->get_dbengine();
428         }
429         $engine = strtolower($engine);
431         if (!isset($collation)) {
432             $collation = $this->get_dbcollation();
433         }
435         $rowformat = '';
436         if (($engine === 'innodb' || $engine === 'xtradb') && strpos($collation, 'utf8mb4_') === 0) {
437             if ($this->is_compressed_row_format_supported()) {
438                 $rowformat = "ROW_FORMAT=Compressed";
439             } else {
440                 $rowformat = "ROW_FORMAT=Dynamic";
441             }
442         }
443         return $rowformat;
444     }
446     /**
447      * Returns localised database type name
448      * Note: can be used before connect()
449      * @return string
450      */
451     public function get_name() {
452         return get_string('nativemysqli', 'install');
453     }
455     /**
456      * Returns localised database configuration help.
457      * Note: can be used before connect()
458      * @return string
459      */
460     public function get_configuration_help() {
461         return get_string('nativemysqlihelp', 'install');
462     }
464     /**
465      * Diagnose database and tables, this function is used
466      * to verify database and driver settings, db engine types, etc.
467      *
468      * @return string null means everything ok, string means problem found.
469      */
470     public function diagnose() {
471         $sloppymyisamfound = false;
472         $prefix = str_replace('_', '\\_', $this->prefix);
473         $sql = "SELECT COUNT('x')
474                   FROM INFORMATION_SCHEMA.TABLES
475                  WHERE table_schema = DATABASE()
476                        AND table_name LIKE BINARY '$prefix%'
477                        AND Engine = 'MyISAM'";
478         $this->query_start($sql, null, SQL_QUERY_AUX);
479         $result = $this->mysqli->query($sql);
480         $this->query_end($result);
481         if ($result) {
482             if ($arr = $result->fetch_assoc()) {
483                 $count = reset($arr);
484                 if ($count) {
485                     $sloppymyisamfound = true;
486                 }
487             }
488             $result->close();
489         }
491         if ($sloppymyisamfound) {
492             return get_string('myisamproblem', 'error');
493         } else {
494             return null;
495         }
496     }
498     /**
499      * Connect to db
500      * Must be called before other methods.
501      * @param string $dbhost The database host.
502      * @param string $dbuser The database username.
503      * @param string $dbpass The database username's password.
504      * @param string $dbname The name of the database being connected to.e
505      * @param mixed $prefix string means moodle db prefix, false used for external databases where prefix not used
506      * @param array $dboptions driver specific options
507      * @return bool success
508      */
509     public function connect($dbhost, $dbuser, $dbpass, $dbname, $prefix, array $dboptions=null) {
510         $driverstatus = $this->driver_installed();
512         if ($driverstatus !== true) {
513             throw new dml_exception('dbdriverproblem', $driverstatus);
514         }
516         $this->store_settings($dbhost, $dbuser, $dbpass, $dbname, $prefix, $dboptions);
518         // dbsocket is used ONLY if host is NULL or 'localhost',
519         // you can not disable it because it is always tried if dbhost is 'localhost'
520         if (!empty($this->dboptions['dbsocket'])
521                 and (strpos($this->dboptions['dbsocket'], '/') !== false or strpos($this->dboptions['dbsocket'], '\\') !== false)) {
522             $dbsocket = $this->dboptions['dbsocket'];
523         } else {
524             $dbsocket = ini_get('mysqli.default_socket');
525         }
526         if (empty($this->dboptions['dbport'])) {
527             $dbport = (int)ini_get('mysqli.default_port');
528         } else {
529             $dbport = (int)$this->dboptions['dbport'];
530         }
531         // verify ini.get does not return nonsense
532         if (empty($dbport)) {
533             $dbport = 3306;
534         }
535         if ($dbhost and !empty($this->dboptions['dbpersist'])) {
536             $dbhost = "p:$dbhost";
537         }
538         $this->mysqli = @new mysqli($dbhost, $dbuser, $dbpass, $dbname, $dbport, $dbsocket);
540         if ($this->mysqli->connect_errno !== 0) {
541             $dberr = $this->mysqli->connect_error;
542             $this->mysqli = null;
543             throw new dml_connection_exception($dberr);
544         }
546         // Disable logging until we are fully setup.
547         $this->query_log_prevent();
549         if (isset($dboptions['dbcollation'])) {
550             $collationinfo = explode('_', $dboptions['dbcollation']);
551             $this->dboptions['dbcollation'] = $dboptions['dbcollation'];
552         } else {
553             $collationinfo = explode('_', $this->get_dbcollation());
554         }
555         $charset = reset($collationinfo);
557         $this->query_start("--set_charset()", null, SQL_QUERY_AUX);
558         $this->mysqli->set_charset($charset);
559         $this->query_end(true);
561         // If available, enforce strict mode for the session. That guaranties
562         // standard behaviour under some situations, avoiding some MySQL nasty
563         // habits like truncating data or performing some transparent cast losses.
564         // With strict mode enforced, Moodle DB layer will be consistently throwing
565         // the corresponding exceptions as expected.
566         $si = $this->get_server_info();
567         if (version_compare($si['version'], '5.0.2', '>=')) {
568             $sql = "SET SESSION sql_mode = 'STRICT_ALL_TABLES'";
569             $this->query_start($sql, null, SQL_QUERY_AUX);
570             $result = $this->mysqli->query($sql);
571             $this->query_end($result);
572         }
574         // We can enable logging now.
575         $this->query_log_allow();
577         // Connection stabilised and configured, going to instantiate the temptables controller
578         $this->temptables = new mysqli_native_moodle_temptables($this);
580         return true;
581     }
583     /**
584      * Close database connection and release all resources
585      * and memory (especially circular memory references).
586      * Do NOT use connect() again, create a new instance if needed.
587      */
588     public function dispose() {
589         parent::dispose(); // Call parent dispose to write/close session and other common stuff before closing connection
590         if ($this->mysqli) {
591             $this->mysqli->close();
592             $this->mysqli = null;
593         }
594     }
596     /**
597      * Returns database server info array
598      * @return array Array containing 'description' and 'version' info
599      */
600     public function get_server_info() {
601         return array('description'=>$this->mysqli->server_info, 'version'=>$this->mysqli->server_info);
602     }
604     /**
605      * Returns supported query parameter types
606      * @return int bitmask of accepted SQL_PARAMS_*
607      */
608     protected function allowed_param_types() {
609         return SQL_PARAMS_QM;
610     }
612     /**
613      * Returns last error reported by database engine.
614      * @return string error message
615      */
616     public function get_last_error() {
617         return $this->mysqli->error;
618     }
620     /**
621      * Return tables in database WITHOUT current prefix
622      * @param bool $usecache if true, returns list of cached tables.
623      * @return array of table names in lowercase and without prefix
624      */
625     public function get_tables($usecache=true) {
626         if ($usecache and $this->tables !== null) {
627             return $this->tables;
628         }
629         $this->tables = array();
630         $prefix = str_replace('_', '\\_', $this->prefix);
631         $sql = "SHOW TABLES LIKE '$prefix%'";
632         $this->query_start($sql, null, SQL_QUERY_AUX);
633         $result = $this->mysqli->query($sql);
634         $this->query_end($result);
635         $len = strlen($this->prefix);
636         if ($result) {
637             while ($arr = $result->fetch_assoc()) {
638                 $tablename = reset($arr);
639                 $tablename = substr($tablename, $len);
640                 $this->tables[$tablename] = $tablename;
641             }
642             $result->close();
643         }
645         // Add the currently available temptables
646         $this->tables = array_merge($this->tables, $this->temptables->get_temptables());
647         return $this->tables;
648     }
650     /**
651      * Return table indexes - everything lowercased.
652      * @param string $table The table we want to get indexes from.
653      * @return array An associative array of indexes containing 'unique' flag and 'columns' being indexed
654      */
655     public function get_indexes($table) {
656         $indexes = array();
657         $sql = "SHOW INDEXES FROM {$this->prefix}$table";
658         $this->query_start($sql, null, SQL_QUERY_AUX);
659         $result = $this->mysqli->query($sql);
660         try {
661             $this->query_end($result);
662         } catch (dml_read_exception $e) {
663             return $indexes; // table does not exist - no indexes...
664         }
665         if ($result) {
666             while ($res = $result->fetch_object()) {
667                 if ($res->Key_name === 'PRIMARY') {
668                     continue;
669                 }
670                 if (!isset($indexes[$res->Key_name])) {
671                     $indexes[$res->Key_name] = array('unique'=>empty($res->Non_unique), 'columns'=>array());
672                 }
673                 $indexes[$res->Key_name]['columns'][$res->Seq_in_index-1] = $res->Column_name;
674             }
675             $result->close();
676         }
677         return $indexes;
678     }
680     /**
681      * Returns detailed information about columns in table. This information is cached internally.
682      * @param string $table name
683      * @param bool $usecache
684      * @return database_column_info[] array of database_column_info objects indexed with column names
685      */
686     public function get_columns($table, $usecache=true) {
687         if ($usecache) {
688             if ($this->temptables->is_temptable($table)) {
689                 if ($data = $this->get_temp_tables_cache()->get($table)) {
690                     return $data;
691                 }
692             } else {
693                 if ($data = $this->get_metacache()->get($table)) {
694                     return $data;
695                 }
696             }
697         }
699         $structure = array();
701         $sql = "SELECT column_name, data_type, character_maximum_length, numeric_precision,
702                        numeric_scale, is_nullable, column_type, column_default, column_key, extra
703                   FROM information_schema.columns
704                  WHERE table_name = '" . $this->prefix.$table . "'
705                        AND table_schema = '" . $this->dbname . "'
706               ORDER BY ordinal_position";
707         $this->query_start($sql, null, SQL_QUERY_AUX);
708         $result = $this->mysqli->query($sql);
709         $this->query_end(true); // Don't want to throw anything here ever. MDL-30147
711         if ($result === false) {
712             return array();
713         }
715         if ($result->num_rows > 0) {
716             // standard table exists
717             while ($rawcolumn = $result->fetch_assoc()) {
718                 // MySQL 8 BC: information_schema.* returns the fields in upper case.
719                 $rawcolumn = array_change_key_case($rawcolumn, CASE_LOWER);
720                 $info = (object)$this->get_column_info((object)$rawcolumn);
721                 $structure[$info->name] = new database_column_info($info);
722             }
723             $result->close();
725         } else {
726             // temporary tables are not in information schema, let's try it the old way
727             $result->close();
728             $sql = "SHOW COLUMNS FROM {$this->prefix}$table";
729             $this->query_start($sql, null, SQL_QUERY_AUX);
730             $result = $this->mysqli->query($sql);
731             $this->query_end(true);
732             if ($result === false) {
733                 return array();
734             }
735             while ($rawcolumn = $result->fetch_assoc()) {
736                 $rawcolumn = (object)array_change_key_case($rawcolumn, CASE_LOWER);
737                 $rawcolumn->column_name              = $rawcolumn->field; unset($rawcolumn->field);
738                 $rawcolumn->column_type              = $rawcolumn->type; unset($rawcolumn->type);
739                 $rawcolumn->character_maximum_length = null;
740                 $rawcolumn->numeric_precision        = null;
741                 $rawcolumn->numeric_scale            = null;
742                 $rawcolumn->is_nullable              = $rawcolumn->null; unset($rawcolumn->null);
743                 $rawcolumn->column_default           = $rawcolumn->default; unset($rawcolumn->default);
744                 $rawcolumn->column_key               = $rawcolumn->key; unset($rawcolumn->key);
746                 if (preg_match('/(enum|varchar)\((\d+)\)/i', $rawcolumn->column_type, $matches)) {
747                     $rawcolumn->data_type = $matches[1];
748                     $rawcolumn->character_maximum_length = $matches[2];
750                 } else if (preg_match('/([a-z]*int[a-z]*)\((\d+)\)/i', $rawcolumn->column_type, $matches)) {
751                     $rawcolumn->data_type = $matches[1];
752                     $rawcolumn->numeric_precision = $matches[2];
753                     $rawcolumn->max_length = $rawcolumn->numeric_precision;
755                     $type = strtoupper($matches[1]);
756                     if ($type === 'BIGINT') {
757                         $maxlength = 18;
758                     } else if ($type === 'INT' or $type === 'INTEGER') {
759                         $maxlength = 9;
760                     } else if ($type === 'MEDIUMINT') {
761                         $maxlength = 6;
762                     } else if ($type === 'SMALLINT') {
763                         $maxlength = 4;
764                     } else if ($type === 'TINYINT') {
765                         $maxlength = 2;
766                     } else {
767                         // This should not happen.
768                         $maxlength = 0;
769                     }
770                     if ($maxlength < $rawcolumn->max_length) {
771                         $rawcolumn->max_length = $maxlength;
772                     }
774                 } else if (preg_match('/(decimal)\((\d+),(\d+)\)/i', $rawcolumn->column_type, $matches)) {
775                     $rawcolumn->data_type = $matches[1];
776                     $rawcolumn->numeric_precision = $matches[2];
777                     $rawcolumn->numeric_scale = $matches[3];
779                 } else if (preg_match('/(double|float)(\((\d+),(\d+)\))?/i', $rawcolumn->column_type, $matches)) {
780                     $rawcolumn->data_type = $matches[1];
781                     $rawcolumn->numeric_precision = isset($matches[3]) ? $matches[3] : null;
782                     $rawcolumn->numeric_scale = isset($matches[4]) ? $matches[4] : null;
784                 } else if (preg_match('/([a-z]*text)/i', $rawcolumn->column_type, $matches)) {
785                     $rawcolumn->data_type = $matches[1];
786                     $rawcolumn->character_maximum_length = -1; // unknown
788                 } else if (preg_match('/([a-z]*blob)/i', $rawcolumn->column_type, $matches)) {
789                     $rawcolumn->data_type = $matches[1];
791                 } else {
792                     $rawcolumn->data_type = $rawcolumn->column_type;
793                 }
795                 $info = $this->get_column_info($rawcolumn);
796                 $structure[$info->name] = new database_column_info($info);
797             }
798             $result->close();
799         }
801         if ($usecache) {
802             if ($this->temptables->is_temptable($table)) {
803                 $this->get_temp_tables_cache()->set($table, $structure);
804             } else {
805                 $this->get_metacache()->set($table, $structure);
806             }
807         }
809         return $structure;
810     }
812     /**
813      * Indicates whether column information retrieved from `information_schema.columns` has default values quoted or not.
814      * @return boolean True when default values are quoted (breaking change); otherwise, false.
815      */
816     protected function has_breaking_change_quoted_defaults() {
817         return false;
818     }
820     /**
821      * Indicates whether SQL_MODE default value has changed in a not backward compatible way.
822      * @return boolean True when SQL_MODE breaks BC; otherwise, false.
823      */
824     public function has_breaking_change_sqlmode() {
825         return false;
826     }
828     /**
829      * Returns moodle column info for raw column from information schema.
830      * @param stdClass $rawcolumn
831      * @return stdClass standardised colum info
832      */
833     private function get_column_info(stdClass $rawcolumn) {
834         $rawcolumn = (object)$rawcolumn;
835         $info = new stdClass();
836         $info->name           = $rawcolumn->column_name;
837         $info->type           = $rawcolumn->data_type;
838         $info->meta_type      = $this->mysqltype2moodletype($rawcolumn->data_type);
839         if ($this->has_breaking_change_quoted_defaults()) {
840             $info->default_value = trim($rawcolumn->column_default, "'");
841             if ($info->default_value === 'NULL') {
842                 $info->default_value = null;
843             }
844         } else {
845             $info->default_value = $rawcolumn->column_default;
846         }
847         $info->has_default    = !is_null($info->default_value);
848         $info->not_null       = ($rawcolumn->is_nullable === 'NO');
849         $info->primary_key    = ($rawcolumn->column_key === 'PRI');
850         $info->binary         = false;
851         $info->unsigned       = null;
852         $info->auto_increment = false;
853         $info->unique         = null;
854         $info->scale          = null;
856         if ($info->meta_type === 'C') {
857             $info->max_length = $rawcolumn->character_maximum_length;
859         } else if ($info->meta_type === 'I') {
860             if ($info->primary_key) {
861                 $info->meta_type = 'R';
862                 $info->unique    = true;
863             }
864             // Return number of decimals, not bytes here.
865             $info->max_length    = $rawcolumn->numeric_precision;
866             if (preg_match('/([a-z]*int[a-z]*)\((\d+)\)/i', $rawcolumn->column_type, $matches)) {
867                 $type = strtoupper($matches[1]);
868                 if ($type === 'BIGINT') {
869                     $maxlength = 18;
870                 } else if ($type === 'INT' or $type === 'INTEGER') {
871                     $maxlength = 9;
872                 } else if ($type === 'MEDIUMINT') {
873                     $maxlength = 6;
874                 } else if ($type === 'SMALLINT') {
875                     $maxlength = 4;
876                 } else if ($type === 'TINYINT') {
877                     $maxlength = 2;
878                 } else {
879                     // This should not happen.
880                     $maxlength = 0;
881                 }
882                 // It is possible that display precision is different from storage type length,
883                 // always use the smaller value to make sure our data fits.
884                 if ($maxlength < $info->max_length) {
885                     $info->max_length = $maxlength;
886                 }
887             }
888             $info->unsigned      = (stripos($rawcolumn->column_type, 'unsigned') !== false);
889             $info->auto_increment= (strpos($rawcolumn->extra, 'auto_increment') !== false);
891         } else if ($info->meta_type === 'N') {
892             $info->max_length    = $rawcolumn->numeric_precision;
893             $info->scale         = $rawcolumn->numeric_scale;
894             $info->unsigned      = (stripos($rawcolumn->column_type, 'unsigned') !== false);
896         } else if ($info->meta_type === 'X') {
897             if ("$rawcolumn->character_maximum_length" === '4294967295') { // watch out for PHP max int limits!
898                 // means maximum moodle size for text column, in other drivers it may also mean unknown size
899                 $info->max_length = -1;
900             } else {
901                 $info->max_length = $rawcolumn->character_maximum_length;
902             }
903             $info->primary_key   = false;
905         } else if ($info->meta_type === 'B') {
906             $info->max_length    = -1;
907             $info->primary_key   = false;
908             $info->binary        = true;
909         }
911         return $info;
912     }
914     /**
915      * Normalise column type.
916      * @param string $mysql_type
917      * @return string one character
918      * @throws dml_exception
919      */
920     private function mysqltype2moodletype($mysql_type) {
921         $type = null;
923         switch(strtoupper($mysql_type)) {
924             case 'BIT':
925                 $type = 'L';
926                 break;
928             case 'TINYINT':
929             case 'SMALLINT':
930             case 'MEDIUMINT':
931             case 'INT':
932             case 'INTEGER':
933             case 'BIGINT':
934                 $type = 'I';
935                 break;
937             case 'FLOAT':
938             case 'DOUBLE':
939             case 'DECIMAL':
940                 $type = 'N';
941                 break;
943             case 'CHAR':
944             case 'ENUM':
945             case 'SET':
946             case 'VARCHAR':
947                 $type = 'C';
948                 break;
950             case 'TINYTEXT':
951             case 'TEXT':
952             case 'MEDIUMTEXT':
953             case 'LONGTEXT':
954                 $type = 'X';
955                 break;
957             case 'BINARY':
958             case 'VARBINARY':
959             case 'BLOB':
960             case 'TINYBLOB':
961             case 'MEDIUMBLOB':
962             case 'LONGBLOB':
963                 $type = 'B';
964                 break;
966             case 'DATE':
967             case 'TIME':
968             case 'DATETIME':
969             case 'TIMESTAMP':
970             case 'YEAR':
971                 $type = 'D';
972                 break;
973         }
975         if (!$type) {
976             throw new dml_exception('invalidmysqlnativetype', $mysql_type);
977         }
978         return $type;
979     }
981     /**
982      * Normalise values based in RDBMS dependencies (booleans, LOBs...)
983      *
984      * @param database_column_info $column column metadata corresponding with the value we are going to normalise
985      * @param mixed $value value we are going to normalise
986      * @return mixed the normalised value
987      */
988     protected function normalise_value($column, $value) {
989         $this->detect_objects($value);
991         if (is_bool($value)) { // Always, convert boolean to int
992             $value = (int)$value;
994         } else if ($value === '') {
995             if ($column->meta_type == 'I' or $column->meta_type == 'F' or $column->meta_type == 'N') {
996                 $value = 0; // prevent '' problems in numeric fields
997             }
998         // Any float value being stored in varchar or text field is converted to string to avoid
999         // any implicit conversion by MySQL
1000         } else if (is_float($value) and ($column->meta_type == 'C' or $column->meta_type == 'X')) {
1001             $value = "$value";
1002         }
1003         return $value;
1004     }
1006     /**
1007      * Is this database compatible with utf8?
1008      * @return bool
1009      */
1010     public function setup_is_unicodedb() {
1011         // All new tables are created with this collation, we just have to make sure it is utf8 compatible,
1012         // if config table already exists it has this collation too.
1013         $collation = $this->get_dbcollation();
1015         $collationinfo = explode('_', $collation);
1016         $charset = reset($collationinfo);
1018         $sql = "SHOW COLLATION WHERE Collation ='$collation' AND Charset = '$charset'";
1019         $this->query_start($sql, NULL, SQL_QUERY_AUX);
1020         $result = $this->mysqli->query($sql);
1021         $this->query_end($result);
1022         if ($result->fetch_assoc()) {
1023             $return = true;
1024         } else {
1025             $return = false;
1026         }
1027         $result->close();
1029         return $return;
1030     }
1032     /**
1033      * Do NOT use in code, to be used by database_manager only!
1034      * @param string|array $sql query
1035      * @param array|null $tablenames an array of xmldb table names affected by this request.
1036      * @return bool true
1037      * @throws ddl_change_structure_exception A DDL specific exception is thrown for any errors.
1038      */
1039     public function change_database_structure($sql, $tablenames = null) {
1040         $this->get_manager(); // Includes DDL exceptions classes ;-)
1041         if (is_array($sql)) {
1042             $sql = implode("\n;\n", $sql);
1043         }
1045         try {
1046             $this->query_start($sql, null, SQL_QUERY_STRUCTURE);
1047             $result = $this->mysqli->multi_query($sql);
1048             if ($result === false) {
1049                 $this->query_end(false);
1050             }
1051             while ($this->mysqli->more_results()) {
1052                 $result = $this->mysqli->next_result();
1053                 if ($result === false) {
1054                     $this->query_end(false);
1055                 }
1056             }
1057             $this->query_end(true);
1058         } catch (ddl_change_structure_exception $e) {
1059             while (@$this->mysqli->more_results()) {
1060                 @$this->mysqli->next_result();
1061             }
1062             $this->reset_caches($tablenames);
1063             throw $e;
1064         }
1066         $this->reset_caches($tablenames);
1067         return true;
1068     }
1070     /**
1071      * Very ugly hack which emulates bound parameters in queries
1072      * because prepared statements do not use query cache.
1073      */
1074     protected function emulate_bound_params($sql, array $params=null) {
1075         if (empty($params)) {
1076             return $sql;
1077         }
1078         // ok, we have verified sql statement with ? and correct number of params
1079         $parts = array_reverse(explode('?', $sql));
1080         $return = array_pop($parts);
1081         foreach ($params as $param) {
1082             if (is_bool($param)) {
1083                 $return .= (int)$param;
1084             } else if (is_null($param)) {
1085                 $return .= 'NULL';
1086             } else if (is_number($param)) {
1087                 $return .= "'".$param."'"; // we have to always use strings because mysql is using weird automatic int casting
1088             } else if (is_float($param)) {
1089                 $return .= $param;
1090             } else {
1091                 $param = $this->mysqli->real_escape_string($param);
1092                 $return .= "'$param'";
1093             }
1094             $return .= array_pop($parts);
1095         }
1096         return $return;
1097     }
1099     /**
1100      * Execute general sql query. Should be used only when no other method suitable.
1101      * Do NOT use this to make changes in db structure, use database_manager methods instead!
1102      * @param string $sql query
1103      * @param array $params query parameters
1104      * @return bool true
1105      * @throws dml_exception A DML specific exception is thrown for any errors.
1106      */
1107     public function execute($sql, array $params=null) {
1108         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1110         if (strpos($sql, ';') !== false) {
1111             throw new coding_exception('moodle_database::execute() Multiple sql statements found or bound parameters not used properly in query!');
1112         }
1114         $rawsql = $this->emulate_bound_params($sql, $params);
1116         $this->query_start($sql, $params, SQL_QUERY_UPDATE);
1117         $result = $this->mysqli->query($rawsql);
1118         $this->query_end($result);
1120         if ($result === true) {
1121             return true;
1123         } else {
1124             $result->close();
1125             return true;
1126         }
1127     }
1129     /**
1130      * Get a number of records as a moodle_recordset using a SQL statement.
1131      *
1132      * Since this method is a little less readable, use of it should be restricted to
1133      * code where it's possible there might be large datasets being returned.  For known
1134      * small datasets use get_records_sql - it leads to simpler code.
1135      *
1136      * The return type is like:
1137      * @see function get_recordset.
1138      *
1139      * @param string $sql the SQL select query to execute.
1140      * @param array $params array of sql parameters
1141      * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set).
1142      * @param int $limitnum return a subset comprising this many records (optional, required if $limitfrom is set).
1143      * @return moodle_recordset instance
1144      * @throws dml_exception A DML specific exception is thrown for any errors.
1145      */
1146     public function get_recordset_sql($sql, array $params=null, $limitfrom=0, $limitnum=0) {
1148         list($limitfrom, $limitnum) = $this->normalise_limit_from_num($limitfrom, $limitnum);
1150         if ($limitfrom or $limitnum) {
1151             if ($limitnum < 1) {
1152                 $limitnum = "18446744073709551615";
1153             }
1154             $sql .= " LIMIT $limitfrom, $limitnum";
1155         }
1157         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1158         $rawsql = $this->emulate_bound_params($sql, $params);
1160         $this->query_start($sql, $params, SQL_QUERY_SELECT);
1161         // no MYSQLI_USE_RESULT here, it would block write ops on affected tables
1162         $result = $this->mysqli->query($rawsql, MYSQLI_STORE_RESULT);
1163         $this->query_end($result);
1165         return $this->create_recordset($result);
1166     }
1168     /**
1169      * Get all records from a table.
1170      *
1171      * This method works around potential memory problems and may improve performance,
1172      * this method may block access to table until the recordset is closed.
1173      *
1174      * @param string $table Name of database table.
1175      * @return moodle_recordset A moodle_recordset instance {@link function get_recordset}.
1176      * @throws dml_exception A DML specific exception is thrown for any errors.
1177      */
1178     public function export_table_recordset($table) {
1179         $sql = $this->fix_table_names("SELECT * FROM {{$table}}");
1181         $this->query_start($sql, array(), SQL_QUERY_SELECT);
1182         // MYSQLI_STORE_RESULT may eat all memory for large tables, unfortunately MYSQLI_USE_RESULT blocks other queries.
1183         $result = $this->mysqli->query($sql, MYSQLI_USE_RESULT);
1184         $this->query_end($result);
1186         return $this->create_recordset($result);
1187     }
1189     protected function create_recordset($result) {
1190         return new mysqli_native_moodle_recordset($result);
1191     }
1193     /**
1194      * Get a number of records as an array of objects using a SQL statement.
1195      *
1196      * Return value is like:
1197      * @see function get_records.
1198      *
1199      * @param string $sql the SQL select query to execute. The first column of this SELECT statement
1200      *   must be a unique value (usually the 'id' field), as it will be used as the key of the
1201      *   returned array.
1202      * @param array $params array of sql parameters
1203      * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set).
1204      * @param int $limitnum return a subset comprising this many records (optional, required if $limitfrom is set).
1205      * @return array of objects, or empty array if no records were found
1206      * @throws dml_exception A DML specific exception is thrown for any errors.
1207      */
1208     public function get_records_sql($sql, array $params=null, $limitfrom=0, $limitnum=0) {
1210         list($limitfrom, $limitnum) = $this->normalise_limit_from_num($limitfrom, $limitnum);
1212         if ($limitfrom or $limitnum) {
1213             if ($limitnum < 1) {
1214                 $limitnum = "18446744073709551615";
1215             }
1216             $sql .= " LIMIT $limitfrom, $limitnum";
1217         }
1219         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1220         $rawsql = $this->emulate_bound_params($sql, $params);
1222         $this->query_start($sql, $params, SQL_QUERY_SELECT);
1223         $result = $this->mysqli->query($rawsql, MYSQLI_STORE_RESULT);
1224         $this->query_end($result);
1226         $return = array();
1228         while($row = $result->fetch_assoc()) {
1229             $row = array_change_key_case($row, CASE_LOWER);
1230             $id  = reset($row);
1231             if (isset($return[$id])) {
1232                 $colname = key($row);
1233                 debugging("Did you remember to make the first column something unique in your call to get_records? Duplicate value '$id' found in column '$colname'.", DEBUG_DEVELOPER);
1234             }
1235             $return[$id] = (object)$row;
1236         }
1237         $result->close();
1239         return $return;
1240     }
1242     /**
1243      * Selects records and return values (first field) as an array using a SQL statement.
1244      *
1245      * @param string $sql The SQL query
1246      * @param array $params array of sql parameters
1247      * @return array of values
1248      * @throws dml_exception A DML specific exception is thrown for any errors.
1249      */
1250     public function get_fieldset_sql($sql, array $params=null) {
1251         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1252         $rawsql = $this->emulate_bound_params($sql, $params);
1254         $this->query_start($sql, $params, SQL_QUERY_SELECT);
1255         $result = $this->mysqli->query($rawsql, MYSQLI_STORE_RESULT);
1256         $this->query_end($result);
1258         $return = array();
1260         while($row = $result->fetch_assoc()) {
1261             $return[] = reset($row);
1262         }
1263         $result->close();
1265         return $return;
1266     }
1268     /**
1269      * Insert new record into database, as fast as possible, no safety checks, lobs not supported.
1270      * @param string $table name
1271      * @param mixed $params data record as object or array
1272      * @param bool $returnit return it of inserted record
1273      * @param bool $bulk true means repeated inserts expected
1274      * @param bool $customsequence true if 'id' included in $params, disables $returnid
1275      * @return bool|int true or new id
1276      * @throws dml_exception A DML specific exception is thrown for any errors.
1277      */
1278     public function insert_record_raw($table, $params, $returnid=true, $bulk=false, $customsequence=false) {
1279         if (!is_array($params)) {
1280             $params = (array)$params;
1281         }
1283         if ($customsequence) {
1284             if (!isset($params['id'])) {
1285                 throw new coding_exception('moodle_database::insert_record_raw() id field must be specified if custom sequences used.');
1286             }
1287             $returnid = false;
1288         } else {
1289             unset($params['id']);
1290         }
1292         if (empty($params)) {
1293             throw new coding_exception('moodle_database::insert_record_raw() no fields found.');
1294         }
1296         $fields = implode(',', array_keys($params));
1297         $qms    = array_fill(0, count($params), '?');
1298         $qms    = implode(',', $qms);
1300         $sql = "INSERT INTO {$this->prefix}$table ($fields) VALUES($qms)";
1302         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1303         $rawsql = $this->emulate_bound_params($sql, $params);
1305         $this->query_start($sql, $params, SQL_QUERY_INSERT);
1306         $result = $this->mysqli->query($rawsql);
1307         $id = @$this->mysqli->insert_id; // must be called before query_end() which may insert log into db
1308         $this->query_end($result);
1310         if (!$customsequence and !$id) {
1311             throw new dml_write_exception('unknown error fetching inserted id');
1312         }
1314         if (!$returnid) {
1315             return true;
1316         } else {
1317             return (int)$id;
1318         }
1319     }
1321     /**
1322      * Insert a record into a table and return the "id" field if required.
1323      *
1324      * Some conversions and safety checks are carried out. Lobs are supported.
1325      * If the return ID isn't required, then this just reports success as true/false.
1326      * $data is an object containing needed data
1327      * @param string $table The database table to be inserted into
1328      * @param object $data A data object with values for one or more fields in the record
1329      * @param bool $returnid Should the id of the newly created record entry be returned? If this option is not requested then true/false is returned.
1330      * @return bool|int true or new id
1331      * @throws dml_exception A DML specific exception is thrown for any errors.
1332      */
1333     public function insert_record($table, $dataobject, $returnid=true, $bulk=false) {
1334         $dataobject = (array)$dataobject;
1336         $columns = $this->get_columns($table);
1337         if (empty($columns)) {
1338             throw new dml_exception('ddltablenotexist', $table);
1339         }
1341         $cleaned = array();
1343         foreach ($dataobject as $field=>$value) {
1344             if ($field === 'id') {
1345                 continue;
1346             }
1347             if (!isset($columns[$field])) {
1348                 continue;
1349             }
1350             $column = $columns[$field];
1351             $cleaned[$field] = $this->normalise_value($column, $value);
1352         }
1354         return $this->insert_record_raw($table, $cleaned, $returnid, $bulk);
1355     }
1357     /**
1358      * Insert multiple records into database as fast as possible.
1359      *
1360      * Order of inserts is maintained, but the operation is not atomic,
1361      * use transactions if necessary.
1362      *
1363      * This method is intended for inserting of large number of small objects,
1364      * do not use for huge objects with text or binary fields.
1365      *
1366      * @since Moodle 2.7
1367      *
1368      * @param string $table  The database table to be inserted into
1369      * @param array|Traversable $dataobjects list of objects to be inserted, must be compatible with foreach
1370      * @return void does not return new record ids
1371      *
1372      * @throws coding_exception if data objects have different structure
1373      * @throws dml_exception A DML specific exception is thrown for any errors.
1374      */
1375     public function insert_records($table, $dataobjects) {
1376         if (!is_array($dataobjects) and !$dataobjects instanceof Traversable) {
1377             throw new coding_exception('insert_records() passed non-traversable object');
1378         }
1380         // MySQL has a relatively small query length limit by default,
1381         // make sure 'max_allowed_packet' in my.cnf is high enough
1382         // if you change the following default...
1383         static $chunksize = null;
1384         if ($chunksize === null) {
1385             if (!empty($this->dboptions['bulkinsertsize'])) {
1386                 $chunksize = (int)$this->dboptions['bulkinsertsize'];
1388             } else {
1389                 if (PHP_INT_SIZE === 4) {
1390                     // Bad luck for Windows, we cannot do any maths with large numbers.
1391                     $chunksize = 5;
1392                 } else {
1393                     $sql = "SHOW VARIABLES LIKE 'max_allowed_packet'";
1394                     $this->query_start($sql, null, SQL_QUERY_AUX);
1395                     $result = $this->mysqli->query($sql);
1396                     $this->query_end($result);
1397                     $size = 0;
1398                     if ($rec = $result->fetch_assoc()) {
1399                         $size = $rec['Value'];
1400                     }
1401                     $result->close();
1402                     // Hopefully 200kb per object are enough.
1403                     $chunksize = (int)($size / 200000);
1404                     if ($chunksize > 50) {
1405                         $chunksize = 50;
1406                     }
1407                 }
1408             }
1409         }
1411         $columns = $this->get_columns($table, true);
1412         $fields = null;
1413         $count = 0;
1414         $chunk = array();
1415         foreach ($dataobjects as $dataobject) {
1416             if (!is_array($dataobject) and !is_object($dataobject)) {
1417                 throw new coding_exception('insert_records() passed invalid record object');
1418             }
1419             $dataobject = (array)$dataobject;
1420             if ($fields === null) {
1421                 $fields = array_keys($dataobject);
1422                 $columns = array_intersect_key($columns, $dataobject);
1423                 unset($columns['id']);
1424             } else if ($fields !== array_keys($dataobject)) {
1425                 throw new coding_exception('All dataobjects in insert_records() must have the same structure!');
1426             }
1428             $count++;
1429             $chunk[] = $dataobject;
1431             if ($count === $chunksize) {
1432                 $this->insert_chunk($table, $chunk, $columns);
1433                 $chunk = array();
1434                 $count = 0;
1435             }
1436         }
1438         if ($count) {
1439             $this->insert_chunk($table, $chunk, $columns);
1440         }
1441     }
1443     /**
1444      * Insert records in chunks.
1445      *
1446      * Note: can be used only from insert_records().
1447      *
1448      * @param string $table
1449      * @param array $chunk
1450      * @param database_column_info[] $columns
1451      */
1452     protected function insert_chunk($table, array $chunk, array $columns) {
1453         $fieldssql = '('.implode(',', array_keys($columns)).')';
1455         $valuessql = '('.implode(',', array_fill(0, count($columns), '?')).')';
1456         $valuessql = implode(',', array_fill(0, count($chunk), $valuessql));
1458         $params = array();
1459         foreach ($chunk as $dataobject) {
1460             foreach ($columns as $field => $column) {
1461                 $params[] = $this->normalise_value($column, $dataobject[$field]);
1462             }
1463         }
1465         $sql = "INSERT INTO {$this->prefix}$table $fieldssql VALUES $valuessql";
1467         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1468         $rawsql = $this->emulate_bound_params($sql, $params);
1470         $this->query_start($sql, $params, SQL_QUERY_INSERT);
1471         $result = $this->mysqli->query($rawsql);
1472         $this->query_end($result);
1473     }
1475     /**
1476      * Import a record into a table, id field is required.
1477      * Safety checks are NOT carried out. Lobs are supported.
1478      *
1479      * @param string $table name of database table to be inserted into
1480      * @param object $dataobject A data object with values for one or more fields in the record
1481      * @return bool true
1482      * @throws dml_exception A DML specific exception is thrown for any errors.
1483      */
1484     public function import_record($table, $dataobject) {
1485         $dataobject = (array)$dataobject;
1487         $columns = $this->get_columns($table);
1488         $cleaned = array();
1490         foreach ($dataobject as $field=>$value) {
1491             if (!isset($columns[$field])) {
1492                 continue;
1493             }
1494             $cleaned[$field] = $value;
1495         }
1497         return $this->insert_record_raw($table, $cleaned, false, true, true);
1498     }
1500     /**
1501      * Update record in database, as fast as possible, no safety checks, lobs not supported.
1502      * @param string $table name
1503      * @param mixed $params data record as object or array
1504      * @param bool true means repeated updates expected
1505      * @return bool true
1506      * @throws dml_exception A DML specific exception is thrown for any errors.
1507      */
1508     public function update_record_raw($table, $params, $bulk=false) {
1509         $params = (array)$params;
1511         if (!isset($params['id'])) {
1512             throw new coding_exception('moodle_database::update_record_raw() id field must be specified.');
1513         }
1514         $id = $params['id'];
1515         unset($params['id']);
1517         if (empty($params)) {
1518             throw new coding_exception('moodle_database::update_record_raw() no fields found.');
1519         }
1521         $sets = array();
1522         foreach ($params as $field=>$value) {
1523             $sets[] = "$field = ?";
1524         }
1526         $params[] = $id; // last ? in WHERE condition
1528         $sets = implode(',', $sets);
1529         $sql = "UPDATE {$this->prefix}$table SET $sets WHERE id=?";
1531         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1532         $rawsql = $this->emulate_bound_params($sql, $params);
1534         $this->query_start($sql, $params, SQL_QUERY_UPDATE);
1535         $result = $this->mysqli->query($rawsql);
1536         $this->query_end($result);
1538         return true;
1539     }
1541     /**
1542      * Update a record in a table
1543      *
1544      * $dataobject is an object containing needed data
1545      * Relies on $dataobject having a variable "id" to
1546      * specify the record to update
1547      *
1548      * @param string $table The database table to be checked against.
1549      * @param object $dataobject An object with contents equal to fieldname=>fieldvalue. Must have an entry for 'id' to map to the table specified.
1550      * @param bool true means repeated updates expected
1551      * @return bool true
1552      * @throws dml_exception A DML specific exception is thrown for any errors.
1553      */
1554     public function update_record($table, $dataobject, $bulk=false) {
1555         $dataobject = (array)$dataobject;
1557         $columns = $this->get_columns($table);
1558         $cleaned = array();
1560         foreach ($dataobject as $field=>$value) {
1561             if (!isset($columns[$field])) {
1562                 continue;
1563             }
1564             $column = $columns[$field];
1565             $cleaned[$field] = $this->normalise_value($column, $value);
1566         }
1568         return $this->update_record_raw($table, $cleaned, $bulk);
1569     }
1571     /**
1572      * Set a single field in every table record which match a particular WHERE clause.
1573      *
1574      * @param string $table The database table to be checked against.
1575      * @param string $newfield the field to set.
1576      * @param string $newvalue the value to set the field to.
1577      * @param string $select A fragment of SQL to be used in a where clause in the SQL call.
1578      * @param array $params array of sql parameters
1579      * @return bool true
1580      * @throws dml_exception A DML specific exception is thrown for any errors.
1581      */
1582     public function set_field_select($table, $newfield, $newvalue, $select, array $params=null) {
1583         if ($select) {
1584             $select = "WHERE $select";
1585         }
1586         if (is_null($params)) {
1587             $params = array();
1588         }
1589         list($select, $params, $type) = $this->fix_sql_params($select, $params);
1591         // Get column metadata
1592         $columns = $this->get_columns($table);
1593         $column = $columns[$newfield];
1595         $normalised_value = $this->normalise_value($column, $newvalue);
1597         if (is_null($normalised_value)) {
1598             $newfield = "$newfield = NULL";
1599         } else {
1600             $newfield = "$newfield = ?";
1601             array_unshift($params, $normalised_value);
1602         }
1603         $sql = "UPDATE {$this->prefix}$table SET $newfield $select";
1604         $rawsql = $this->emulate_bound_params($sql, $params);
1606         $this->query_start($sql, $params, SQL_QUERY_UPDATE);
1607         $result = $this->mysqli->query($rawsql);
1608         $this->query_end($result);
1610         return true;
1611     }
1613     /**
1614      * Delete one or more records from a table which match a particular WHERE clause.
1615      *
1616      * @param string $table The database table to be checked against.
1617      * @param string $select A fragment of SQL to be used in a where clause in the SQL call (used to define the selection criteria).
1618      * @param array $params array of sql parameters
1619      * @return bool true
1620      * @throws dml_exception A DML specific exception is thrown for any errors.
1621      */
1622     public function delete_records_select($table, $select, array $params=null) {
1623         if ($select) {
1624             $select = "WHERE $select";
1625         }
1626         $sql = "DELETE FROM {$this->prefix}$table $select";
1628         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1629         $rawsql = $this->emulate_bound_params($sql, $params);
1631         $this->query_start($sql, $params, SQL_QUERY_UPDATE);
1632         $result = $this->mysqli->query($rawsql);
1633         $this->query_end($result);
1635         return true;
1636     }
1638     public function sql_cast_char2int($fieldname, $text=false) {
1639         return ' CAST(' . $fieldname . ' AS SIGNED) ';
1640     }
1642     public function sql_cast_char2real($fieldname, $text=false) {
1643         // Set to 65 (max mysql 5.5 precision) with 7 as scale
1644         // because we must ensure at least 6 decimal positions
1645         // per casting given that postgres is casting to that scale (::real::).
1646         // Can be raised easily but that must be done in all DBs and tests.
1647         return ' CAST(' . $fieldname . ' AS DECIMAL(65,7)) ';
1648     }
1650     public function sql_equal($fieldname, $param, $casesensitive = true, $accentsensitive = true, $notequal = false) {
1651         $equalop = $notequal ? '<>' : '=';
1653         $collationinfo = explode('_', $this->get_dbcollation());
1654         $bincollate = reset($collationinfo) . '_bin';
1656         if ($casesensitive) {
1657             // Current MySQL versions do not support case sensitive and accent insensitive.
1658             return "$fieldname COLLATE $bincollate $equalop $param";
1659         } else if ($accentsensitive) {
1660             // Case insensitive and accent sensitive, we can force a binary comparison once all texts are using the same case.
1661             return "LOWER($fieldname) COLLATE $bincollate $equalop LOWER($param)";
1662         } else {
1663             // Case insensitive and accent insensitive. All collations are that way, but utf8_bin.
1664             $collation = '';
1665             if ($this->get_dbcollation() == 'utf8_bin') {
1666                 $collation = 'COLLATE utf8_unicode_ci';
1667             } else if ($this->get_dbcollation() == 'utf8mb4_bin') {
1668                 $collation = 'COLLATE utf8mb4_unicode_ci';
1669             }
1670             return "$fieldname $collation $equalop $param";
1671         }
1672     }
1674     /**
1675      * Returns 'LIKE' part of a query.
1676      *
1677      * Note that mysql does not support $casesensitive = true and $accentsensitive = false.
1678      * More information in http://bugs.mysql.com/bug.php?id=19567.
1679      *
1680      * @param string $fieldname usually name of the table column
1681      * @param string $param usually bound query parameter (?, :named)
1682      * @param bool $casesensitive use case sensitive search
1683      * @param bool $accensensitive use accent sensitive search (ignored if $casesensitive is true)
1684      * @param bool $notlike true means "NOT LIKE"
1685      * @param string $escapechar escape char for '%' and '_'
1686      * @return string SQL code fragment
1687      */
1688     public function sql_like($fieldname, $param, $casesensitive = true, $accentsensitive = true, $notlike = false, $escapechar = '\\') {
1689         if (strpos($param, '%') !== false) {
1690             debugging('Potential SQL injection detected, sql_like() expects bound parameters (? or :named)');
1691         }
1692         $escapechar = $this->mysqli->real_escape_string($escapechar); // prevents problems with C-style escapes of enclosing '\'
1694         $collationinfo = explode('_', $this->get_dbcollation());
1695         $bincollate = reset($collationinfo) . '_bin';
1697         $LIKE = $notlike ? 'NOT LIKE' : 'LIKE';
1699         if ($casesensitive) {
1700             // Current MySQL versions do not support case sensitive and accent insensitive.
1701             return "$fieldname $LIKE $param COLLATE $bincollate ESCAPE '$escapechar'";
1703         } else if ($accentsensitive) {
1704             // Case insensitive and accent sensitive, we can force a binary comparison once all texts are using the same case.
1705             return "LOWER($fieldname) $LIKE LOWER($param) COLLATE $bincollate ESCAPE '$escapechar'";
1707         } else {
1708             // Case insensitive and accent insensitive.
1709             $collation = '';
1710             if ($this->get_dbcollation() == 'utf8_bin') {
1711                 // Force a case insensitive comparison if using utf8_bin.
1712                 $collation = 'COLLATE utf8_unicode_ci';
1713             } else if ($this->get_dbcollation() == 'utf8mb4_bin') {
1714                 // Force a case insensitive comparison if using utf8mb4_bin.
1715                 $collation = 'COLLATE utf8mb4_unicode_ci';
1716             }
1718             return "$fieldname $LIKE $param $collation ESCAPE '$escapechar'";
1719         }
1720     }
1722     /**
1723      * Returns the proper SQL to do CONCAT between the elements passed
1724      * Can take many parameters
1725      *
1726      * @param string $str,... 1 or more fields/strings to concat
1727      *
1728      * @return string The concat sql
1729      */
1730     public function sql_concat() {
1731         $arr = func_get_args();
1732         $s = implode(', ', $arr);
1733         if ($s === '') {
1734             return "''";
1735         }
1736         return "CONCAT($s)";
1737     }
1739     /**
1740      * Returns the proper SQL to do CONCAT between the elements passed
1741      * with a given separator
1742      *
1743      * @param string $separator The string to use as the separator
1744      * @param array $elements An array of items to concatenate
1745      * @return string The concat SQL
1746      */
1747     public function sql_concat_join($separator="' '", $elements=array()) {
1748         $s = implode(', ', $elements);
1750         if ($s === '') {
1751             return "''";
1752         }
1753         return "CONCAT_WS($separator, $s)";
1754     }
1756     /**
1757      * Returns the SQL text to be used to calculate the length in characters of one expression.
1758      * @param string fieldname or expression to calculate its length in characters.
1759      * @return string the piece of SQL code to be used in the statement.
1760      */
1761     public function sql_length($fieldname) {
1762         return ' CHAR_LENGTH(' . $fieldname . ')';
1763     }
1765     /**
1766      * Does this driver support regex syntax when searching
1767      */
1768     public function sql_regex_supported() {
1769         return true;
1770     }
1772     /**
1773      * Return regex positive or negative match sql
1774      * @param bool $positivematch
1775      * @param bool $casesensitive
1776      * @return string or empty if not supported
1777      */
1778     public function sql_regex($positivematch = true, $casesensitive = false) {
1779         $collation = '';
1780         if ($casesensitive) {
1781             if (substr($this->get_dbcollation(), -4) !== '_bin') {
1782                 $collationinfo = explode('_', $this->get_dbcollation());
1783                 $collation = 'COLLATE ' . $collationinfo[0] . '_bin ';
1784             }
1785         } else {
1786             if ($this->get_dbcollation() == 'utf8_bin') {
1787                 $collation = 'COLLATE utf8_unicode_ci ';
1788             } else if ($this->get_dbcollation() == 'utf8mb4_bin') {
1789                 $collation = 'COLLATE utf8mb4_unicode_ci ';
1790             }
1791         }
1793         return $collation . ($positivematch ? 'REGEXP' : 'NOT REGEXP');
1794     }
1796     /**
1797      * Returns the SQL to be used in order to an UNSIGNED INTEGER column to SIGNED.
1798      *
1799      * @deprecated since 2.3
1800      * @param string $fieldname The name of the field to be cast
1801      * @return string The piece of SQL code to be used in your statement.
1802      */
1803     public function sql_cast_2signed($fieldname) {
1804         return ' CAST(' . $fieldname . ' AS SIGNED) ';
1805     }
1807     /**
1808      * Returns the SQL that allows to find intersection of two or more queries
1809      *
1810      * @since Moodle 2.8
1811      *
1812      * @param array $selects array of SQL select queries, each of them only returns fields with the names from $fields
1813      * @param string $fields comma-separated list of fields
1814      * @return string SQL query that will return only values that are present in each of selects
1815      */
1816     public function sql_intersect($selects, $fields) {
1817         if (count($selects) <= 1) {
1818             return parent::sql_intersect($selects, $fields);
1819         }
1820         $fields = preg_replace('/\s/', '', $fields);
1821         static $aliascnt = 0;
1822         $falias = 'intsctal'.($aliascnt++);
1823         $rv = "SELECT $falias.".
1824             preg_replace('/,/', ','.$falias.'.', $fields).
1825             " FROM ($selects[0]) $falias";
1826         for ($i = 1; $i < count($selects); $i++) {
1827             $alias = 'intsctal'.($aliascnt++);
1828             $rv .= " JOIN (".$selects[$i].") $alias ON ".
1829                 join(' AND ',
1830                     array_map(
1831                         function($a) use ($alias, $falias) {
1832                             return $falias . '.' . $a .' = ' . $alias . '.' . $a;
1833                         },
1834                         preg_split('/,/', $fields))
1835                 );
1836         }
1837         return $rv;
1838     }
1840     /**
1841      * Does this driver support tool_replace?
1842      *
1843      * @since Moodle 2.6.1
1844      * @return bool
1845      */
1846     public function replace_all_text_supported() {
1847         return true;
1848     }
1850     public function session_lock_supported() {
1851         return true;
1852     }
1854     /**
1855      * Obtain session lock
1856      * @param int $rowid id of the row with session record
1857      * @param int $timeout max allowed time to wait for the lock in seconds
1858      * @return void
1859      */
1860     public function get_session_lock($rowid, $timeout) {
1861         parent::get_session_lock($rowid, $timeout);
1863         $fullname = $this->dbname.'-'.$this->prefix.'-session-'.$rowid;
1864         $sql = "SELECT GET_LOCK('$fullname', $timeout)";
1865         $this->query_start($sql, null, SQL_QUERY_AUX);
1866         $result = $this->mysqli->query($sql);
1867         $this->query_end($result);
1869         if ($result) {
1870             $arr = $result->fetch_assoc();
1871             $result->close();
1873             if (reset($arr) == 1) {
1874                 return;
1875             } else {
1876                 throw new dml_sessionwait_exception();
1877             }
1878         }
1879     }
1881     public function release_session_lock($rowid) {
1882         if (!$this->used_for_db_sessions) {
1883             return;
1884         }
1886         parent::release_session_lock($rowid);
1887         $fullname = $this->dbname.'-'.$this->prefix.'-session-'.$rowid;
1888         $sql = "SELECT RELEASE_LOCK('$fullname')";
1889         $this->query_start($sql, null, SQL_QUERY_AUX);
1890         $result = $this->mysqli->query($sql);
1891         $this->query_end($result);
1893         if ($result) {
1894             $result->close();
1895         }
1896     }
1898     /**
1899      * Are transactions supported?
1900      * It is not responsible to run productions servers
1901      * on databases without transaction support ;-)
1902      *
1903      * MyISAM does not support support transactions.
1904      *
1905      * You can override this via the dbtransactions option.
1906      *
1907      * @return bool
1908      */
1909     protected function transactions_supported() {
1910         if (!is_null($this->transactions_supported)) {
1911             return $this->transactions_supported;
1912         }
1914         // this is all just guessing, might be better to just specify it in config.php
1915         if (isset($this->dboptions['dbtransactions'])) {
1916             $this->transactions_supported = $this->dboptions['dbtransactions'];
1917             return $this->transactions_supported;
1918         }
1920         $this->transactions_supported = false;
1922         $engine = $this->get_dbengine();
1924         // Only will accept transactions if using compatible storage engine (more engines can be added easily BDB, Falcon...)
1925         if (in_array($engine, array('InnoDB', 'INNOBASE', 'BDB', 'XtraDB', 'Aria', 'Falcon'))) {
1926             $this->transactions_supported = true;
1927         }
1929         return $this->transactions_supported;
1930     }
1932     /**
1933      * Driver specific start of real database transaction,
1934      * this can not be used directly in code.
1935      * @return void
1936      */
1937     protected function begin_transaction() {
1938         if (!$this->transactions_supported()) {
1939             return;
1940         }
1942         $sql = "SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED";
1943         $this->query_start($sql, NULL, SQL_QUERY_AUX);
1944         $result = $this->mysqli->query($sql);
1945         $this->query_end($result);
1947         $sql = "START TRANSACTION";
1948         $this->query_start($sql, NULL, SQL_QUERY_AUX);
1949         $result = $this->mysqli->query($sql);
1950         $this->query_end($result);
1951     }
1953     /**
1954      * Driver specific commit of real database transaction,
1955      * this can not be used directly in code.
1956      * @return void
1957      */
1958     protected function commit_transaction() {
1959         if (!$this->transactions_supported()) {
1960             return;
1961         }
1963         $sql = "COMMIT";
1964         $this->query_start($sql, NULL, SQL_QUERY_AUX);
1965         $result = $this->mysqli->query($sql);
1966         $this->query_end($result);
1967     }
1969     /**
1970      * Driver specific abort of real database transaction,
1971      * this can not be used directly in code.
1972      * @return void
1973      */
1974     protected function rollback_transaction() {
1975         if (!$this->transactions_supported()) {
1976             return;
1977         }
1979         $sql = "ROLLBACK";
1980         $this->query_start($sql, NULL, SQL_QUERY_AUX);
1981         $result = $this->mysqli->query($sql);
1982         $this->query_end($result);
1984         return true;
1985     }
1987     /**
1988      * Converts a table to either 'Compressed' or 'Dynamic' row format.
1989      *
1990      * @param string $tablename Name of the table to convert to the new row format.
1991      */
1992     public function convert_table_row_format($tablename) {
1993         $currentrowformat = $this->get_row_format($tablename);
1994         if ($currentrowformat == 'Compact' || $currentrowformat == 'Redundant') {
1995             $rowformat = ($this->is_compressed_row_format_supported(false)) ? "ROW_FORMAT=Compressed" : "ROW_FORMAT=Dynamic";
1996             $prefix = $this->get_prefix();
1997             $this->change_database_structure("ALTER TABLE {$prefix}$tablename $rowformat");
1998         }
1999     }
2001     /**
2002      * Does this mysql instance support fulltext indexes?
2003      *
2004      * @return bool
2005      */
2006     public function is_fulltext_search_supported() {
2007         $info = $this->get_server_info();
2009         if (version_compare($info['version'], '5.6.4', '>=')) {
2010             return true;
2011         }
2012         return false;
2013     }