ea7676affd9d31638bdc0c48c1b7d08f64c1d358
[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         if (isset($dboptions['dbcollation']) and strpos($dboptions['dbcollation'], 'utf8_') === 0) {
89             $collation = $dboptions['dbcollation'];
90         } else {
91             $collation = 'utf8_unicode_ci';
92         }
94         $result = $conn->query("CREATE DATABASE $dbname DEFAULT CHARACTER SET utf8 DEFAULT COLLATE ".$collation);
96         $conn->close();
98         if (!$result) {
99             throw new dml_exception('cannotcreatedb');
100         }
102         return true;
103     }
105     /**
106      * Detects if all needed PHP stuff installed.
107      * Note: can be used before connect()
108      * @return mixed true if ok, string if something
109      */
110     public function driver_installed() {
111         if (!extension_loaded('mysqli')) {
112             return get_string('mysqliextensionisnotpresentinphp', 'install');
113         }
114         return true;
115     }
117     /**
118      * Returns database family type - describes SQL dialect
119      * Note: can be used before connect()
120      * @return string db family name (mysql, postgres, mssql, oracle, etc.)
121      */
122     public function get_dbfamily() {
123         return 'mysql';
124     }
126     /**
127      * Returns more specific database driver type
128      * Note: can be used before connect()
129      * @return string db type mysqli, pgsql, oci, mssql, sqlsrv
130      */
131     protected function get_dbtype() {
132         return 'mysqli';
133     }
135     /**
136      * Returns general database library name
137      * Note: can be used before connect()
138      * @return string db type pdo, native
139      */
140     protected function get_dblibrary() {
141         return 'native';
142     }
144     /**
145      * Returns the current MySQL db engine.
146      *
147      * This is an ugly workaround for MySQL default engine problems,
148      * Moodle is designed to work best on ACID compliant databases
149      * with full transaction support. Do not use MyISAM.
150      *
151      * @return string or null MySQL engine name
152      */
153     public function get_dbengine() {
154         if (isset($this->dboptions['dbengine'])) {
155             return $this->dboptions['dbengine'];
156         }
158         if ($this->external) {
159             return null;
160         }
162         $engine = null;
164         // Look for current engine of our config table (the first table that gets created),
165         // so that we create all tables with the same engine.
166         $sql = "SELECT engine
167                   FROM INFORMATION_SCHEMA.TABLES
168                  WHERE table_schema = DATABASE() AND table_name = '{$this->prefix}config'";
169         $this->query_start($sql, NULL, SQL_QUERY_AUX);
170         $result = $this->mysqli->query($sql);
171         $this->query_end($result);
172         if ($rec = $result->fetch_assoc()) {
173             $engine = $rec['engine'];
174         }
175         $result->close();
177         if ($engine) {
178             // Cache the result to improve performance.
179             $this->dboptions['dbengine'] = $engine;
180             return $engine;
181         }
183         // Get the default database engine.
184         $sql = "SELECT @@default_storage_engine engine";
185         $this->query_start($sql, NULL, SQL_QUERY_AUX);
186         $result = $this->mysqli->query($sql);
187         $this->query_end($result);
188         if ($rec = $result->fetch_assoc()) {
189             $engine = $rec['engine'];
190         }
191         $result->close();
193         if ($engine === 'MyISAM') {
194             // we really do not want MyISAM for Moodle, InnoDB or XtraDB is a reasonable defaults if supported
195             $sql = "SHOW STORAGE ENGINES";
196             $this->query_start($sql, NULL, SQL_QUERY_AUX);
197             $result = $this->mysqli->query($sql);
198             $this->query_end($result);
199             $engines = array();
200             while ($res = $result->fetch_assoc()) {
201                 if ($res['Support'] === 'YES' or $res['Support'] === 'DEFAULT') {
202                     $engines[$res['Engine']] = true;
203                 }
204             }
205             $result->close();
206             if (isset($engines['InnoDB'])) {
207                 $engine = 'InnoDB';
208             }
209             if (isset($engines['XtraDB'])) {
210                 $engine = 'XtraDB';
211             }
212         }
214         // Cache the result to improve performance.
215         $this->dboptions['dbengine'] = $engine;
216         return $engine;
217     }
219     /**
220      * Returns the current MySQL db collation.
221      *
222      * This is an ugly workaround for MySQL default collation problems.
223      *
224      * @return string or null MySQL collation name
225      */
226     public function get_dbcollation() {
227         if (isset($this->dboptions['dbcollation'])) {
228             return $this->dboptions['dbcollation'];
229         }
230         if ($this->external) {
231             return null;
232         }
234         $collation = null;
236         // Look for current collation of our config table (the first table that gets created),
237         // so that we create all tables with the same collation.
238         $sql = "SELECT collation_name
239                   FROM INFORMATION_SCHEMA.COLUMNS
240                  WHERE table_schema = DATABASE() AND table_name = '{$this->prefix}config' AND column_name = 'value'";
241         $this->query_start($sql, NULL, SQL_QUERY_AUX);
242         $result = $this->mysqli->query($sql);
243         $this->query_end($result);
244         if ($rec = $result->fetch_assoc()) {
245             $collation = $rec['collation_name'];
246         }
247         $result->close();
249         if (!$collation) {
250             // Get the default database collation, but only if using UTF-8.
251             $sql = "SELECT @@collation_database";
252             $this->query_start($sql, NULL, SQL_QUERY_AUX);
253             $result = $this->mysqli->query($sql);
254             $this->query_end($result);
255             if ($rec = $result->fetch_assoc()) {
256                 if (strpos($rec['@@collation_database'], 'utf8_') === 0) {
257                     $collation = $rec['@@collation_database'];
258                 }
259             }
260             $result->close();
261         }
263         if (!$collation) {
264             // We want only utf8 compatible collations.
265             $collation = null;
266             $sql = "SHOW COLLATION WHERE Collation LIKE 'utf8\_%' AND Charset = 'utf8'";
267             $this->query_start($sql, NULL, SQL_QUERY_AUX);
268             $result = $this->mysqli->query($sql);
269             $this->query_end($result);
270             while ($res = $result->fetch_assoc()) {
271                 $collation = $res['Collation'];
272                 if (strtoupper($res['Default']) === 'YES') {
273                     $collation = $res['Collation'];
274                     break;
275                 }
276             }
277             $result->close();
278         }
280         // Cache the result to improve performance.
281         $this->dboptions['dbcollation'] = $collation;
282         return $collation;
283     }
285     /**
286      * Get the row format from the database schema.
287      *
288      * @param string $table
289      * @return string row_format name or null if not known or table does not exist.
290      */
291     public function get_row_format($table) {
292         $rowformat = null;
293         $table = $this->mysqli->real_escape_string($table);
294         $sql = "SELECT row_format
295                   FROM INFORMATION_SCHEMA.TABLES
296                  WHERE table_schema = DATABASE() AND table_name = '{$this->prefix}$table'";
297         $this->query_start($sql, NULL, SQL_QUERY_AUX);
298         $result = $this->mysqli->query($sql);
299         $this->query_end($result);
300         if ($rec = $result->fetch_assoc()) {
301             $rowformat = $rec['row_format'];
302         }
303         $result->close();
305         return $rowformat;
306     }
308     /**
309      * Is this database compatible with compressed row format?
310      * This feature is necessary for support of large number of text
311      * columns in InnoDB/XtraDB database.
312      *
313      * @param bool $cached use cached result
314      * @return bool true if table can be created or changed to compressed row format.
315      */
316     public function is_compressed_row_format_supported($cached = true) {
317         if ($cached and isset($this->compressedrowformatsupported)) {
318             return($this->compressedrowformatsupported);
319         }
321         $engine = strtolower($this->get_dbengine());
322         $info = $this->get_server_info();
324         if (version_compare($info['version'], '5.5.0') < 0) {
325             // MySQL 5.1 is not supported here because we cannot read the file format.
326             $this->compressedrowformatsupported = false;
328         } else if ($engine !== 'innodb' and $engine !== 'xtradb') {
329             // Other engines are not supported, most probably not compatible.
330             $this->compressedrowformatsupported = false;
332         } else if (!$filepertable = $this->get_record_sql("SHOW VARIABLES LIKE 'innodb_file_per_table'")) {
333             $this->compressedrowformatsupported = false;
335         } else if ($filepertable->value !== 'ON') {
336             $this->compressedrowformatsupported = false;
338         } else if (!$fileformat = $this->get_record_sql("SHOW VARIABLES LIKE 'innodb_file_format'")) {
339             $this->compressedrowformatsupported = false;
341         } else  if ($fileformat->value !== 'Barracuda') {
342             $this->compressedrowformatsupported = false;
344         } else {
345             // All the tests passed, we can safely use ROW_FORMAT=Compressed in sql statements.
346             $this->compressedrowformatsupported = true;
347         }
349         return $this->compressedrowformatsupported;
350     }
352     /**
353      * Returns localised database type name
354      * Note: can be used before connect()
355      * @return string
356      */
357     public function get_name() {
358         return get_string('nativemysqli', 'install');
359     }
361     /**
362      * Returns localised database configuration help.
363      * Note: can be used before connect()
364      * @return string
365      */
366     public function get_configuration_help() {
367         return get_string('nativemysqlihelp', 'install');
368     }
370     /**
371      * Diagnose database and tables, this function is used
372      * to verify database and driver settings, db engine types, etc.
373      *
374      * @return string null means everything ok, string means problem found.
375      */
376     public function diagnose() {
377         $sloppymyisamfound = false;
378         $prefix = str_replace('_', '\\_', $this->prefix);
379         $sql = "SELECT COUNT('x')
380                   FROM INFORMATION_SCHEMA.TABLES
381                  WHERE table_schema = DATABASE()
382                        AND table_name LIKE BINARY '$prefix%'
383                        AND Engine = 'MyISAM'";
384         $this->query_start($sql, null, SQL_QUERY_AUX);
385         $result = $this->mysqli->query($sql);
386         $this->query_end($result);
387         if ($result) {
388             if ($arr = $result->fetch_assoc()) {
389                 $count = reset($arr);
390                 if ($count) {
391                     $sloppymyisamfound = true;
392                 }
393             }
394             $result->close();
395         }
397         if ($sloppymyisamfound) {
398             return get_string('myisamproblem', 'error');
399         } else {
400             return null;
401         }
402     }
404     /**
405      * Connect to db
406      * Must be called before other methods.
407      * @param string $dbhost The database host.
408      * @param string $dbuser The database username.
409      * @param string $dbpass The database username's password.
410      * @param string $dbname The name of the database being connected to.e
411      * @param mixed $prefix string means moodle db prefix, false used for external databases where prefix not used
412      * @param array $dboptions driver specific options
413      * @return bool success
414      */
415     public function connect($dbhost, $dbuser, $dbpass, $dbname, $prefix, array $dboptions=null) {
416         $driverstatus = $this->driver_installed();
418         if ($driverstatus !== true) {
419             throw new dml_exception('dbdriverproblem', $driverstatus);
420         }
422         $this->store_settings($dbhost, $dbuser, $dbpass, $dbname, $prefix, $dboptions);
424         // dbsocket is used ONLY if host is NULL or 'localhost',
425         // you can not disable it because it is always tried if dbhost is 'localhost'
426         if (!empty($this->dboptions['dbsocket'])
427                 and (strpos($this->dboptions['dbsocket'], '/') !== false or strpos($this->dboptions['dbsocket'], '\\') !== false)) {
428             $dbsocket = $this->dboptions['dbsocket'];
429         } else {
430             $dbsocket = ini_get('mysqli.default_socket');
431         }
432         if (empty($this->dboptions['dbport'])) {
433             $dbport = (int)ini_get('mysqli.default_port');
434         } else {
435             $dbport = (int)$this->dboptions['dbport'];
436         }
437         // verify ini.get does not return nonsense
438         if (empty($dbport)) {
439             $dbport = 3306;
440         }
441         if ($dbhost and !empty($this->dboptions['dbpersist'])) {
442             $dbhost = "p:$dbhost";
443         }
444         $this->mysqli = @new mysqli($dbhost, $dbuser, $dbpass, $dbname, $dbport, $dbsocket);
446         if ($this->mysqli->connect_errno !== 0) {
447             $dberr = $this->mysqli->connect_error;
448             $this->mysqli = null;
449             throw new dml_connection_exception($dberr);
450         }
452         // Disable logging until we are fully setup.
453         $this->query_log_prevent();
455         $this->query_start("--set_charset()", null, SQL_QUERY_AUX);
456         $this->mysqli->set_charset('utf8');
457         $this->query_end(true);
459         // If available, enforce strict mode for the session. That guaranties
460         // standard behaviour under some situations, avoiding some MySQL nasty
461         // habits like truncating data or performing some transparent cast losses.
462         // With strict mode enforced, Moodle DB layer will be consistently throwing
463         // the corresponding exceptions as expected.
464         $si = $this->get_server_info();
465         if (version_compare($si['version'], '5.0.2', '>=')) {
466             $sql = "SET SESSION sql_mode = 'STRICT_ALL_TABLES'";
467             $this->query_start($sql, null, SQL_QUERY_AUX);
468             $result = $this->mysqli->query($sql);
469             $this->query_end($result);
470         }
472         // We can enable logging now.
473         $this->query_log_allow();
475         // Connection stabilised and configured, going to instantiate the temptables controller
476         $this->temptables = new mysqli_native_moodle_temptables($this);
478         return true;
479     }
481     /**
482      * Close database connection and release all resources
483      * and memory (especially circular memory references).
484      * Do NOT use connect() again, create a new instance if needed.
485      */
486     public function dispose() {
487         parent::dispose(); // Call parent dispose to write/close session and other common stuff before closing connection
488         if ($this->mysqli) {
489             $this->mysqli->close();
490             $this->mysqli = null;
491         }
492     }
494     /**
495      * Returns database server info array
496      * @return array Array containing 'description' and 'version' info
497      */
498     public function get_server_info() {
499         return array('description'=>$this->mysqli->server_info, 'version'=>$this->mysqli->server_info);
500     }
502     /**
503      * Returns supported query parameter types
504      * @return int bitmask of accepted SQL_PARAMS_*
505      */
506     protected function allowed_param_types() {
507         return SQL_PARAMS_QM;
508     }
510     /**
511      * Returns last error reported by database engine.
512      * @return string error message
513      */
514     public function get_last_error() {
515         return $this->mysqli->error;
516     }
518     /**
519      * Return tables in database WITHOUT current prefix
520      * @param bool $usecache if true, returns list of cached tables.
521      * @return array of table names in lowercase and without prefix
522      */
523     public function get_tables($usecache=true) {
524         if ($usecache and $this->tables !== null) {
525             return $this->tables;
526         }
527         $this->tables = array();
528         $prefix = str_replace('_', '\\_', $this->prefix);
529         $sql = "SHOW TABLES LIKE '$prefix%'";
530         $this->query_start($sql, null, SQL_QUERY_AUX);
531         $result = $this->mysqli->query($sql);
532         $this->query_end($result);
533         $len = strlen($this->prefix);
534         if ($result) {
535             while ($arr = $result->fetch_assoc()) {
536                 $tablename = reset($arr);
537                 $tablename = substr($tablename, $len);
538                 $this->tables[$tablename] = $tablename;
539             }
540             $result->close();
541         }
543         // Add the currently available temptables
544         $this->tables = array_merge($this->tables, $this->temptables->get_temptables());
545         return $this->tables;
546     }
548     /**
549      * Return table indexes - everything lowercased.
550      * @param string $table The table we want to get indexes from.
551      * @return array An associative array of indexes containing 'unique' flag and 'columns' being indexed
552      */
553     public function get_indexes($table) {
554         $indexes = array();
555         $sql = "SHOW INDEXES FROM {$this->prefix}$table";
556         $this->query_start($sql, null, SQL_QUERY_AUX);
557         $result = $this->mysqli->query($sql);
558         try {
559             $this->query_end($result);
560         } catch (dml_read_exception $e) {
561             return $indexes; // table does not exist - no indexes...
562         }
563         if ($result) {
564             while ($res = $result->fetch_object()) {
565                 if ($res->Key_name === 'PRIMARY') {
566                     continue;
567                 }
568                 if (!isset($indexes[$res->Key_name])) {
569                     $indexes[$res->Key_name] = array('unique'=>empty($res->Non_unique), 'columns'=>array());
570                 }
571                 $indexes[$res->Key_name]['columns'][$res->Seq_in_index-1] = $res->Column_name;
572             }
573             $result->close();
574         }
575         return $indexes;
576     }
578     /**
579      * Returns detailed information about columns in table. This information is cached internally.
580      * @param string $table name
581      * @param bool $usecache
582      * @return database_column_info[] array of database_column_info objects indexed with column names
583      */
584     public function get_columns($table, $usecache=true) {
585         if ($usecache) {
586             if ($this->temptables->is_temptable($table)) {
587                 if ($data = $this->get_temp_tables_cache()->get($table)) {
588                     return $data;
589                 }
590             } else {
591                 if ($data = $this->get_metacache()->get($table)) {
592                     return $data;
593                 }
594             }
595         }
597         $structure = array();
599         $sql = "SELECT column_name, data_type, character_maximum_length, numeric_precision,
600                        numeric_scale, is_nullable, column_type, column_default, column_key, extra
601                   FROM information_schema.columns
602                  WHERE table_name = '" . $this->prefix.$table . "'
603                        AND table_schema = '" . $this->dbname . "'
604               ORDER BY ordinal_position";
605         $this->query_start($sql, null, SQL_QUERY_AUX);
606         $result = $this->mysqli->query($sql);
607         $this->query_end(true); // Don't want to throw anything here ever. MDL-30147
609         if ($result === false) {
610             return array();
611         }
613         if ($result->num_rows > 0) {
614             // standard table exists
615             while ($rawcolumn = $result->fetch_assoc()) {
616                 $info = (object)$this->get_column_info((object)$rawcolumn);
617                 $structure[$info->name] = new database_column_info($info);
618             }
619             $result->close();
621         } else {
622             // temporary tables are not in information schema, let's try it the old way
623             $result->close();
624             $sql = "SHOW COLUMNS FROM {$this->prefix}$table";
625             $this->query_start($sql, null, SQL_QUERY_AUX);
626             $result = $this->mysqli->query($sql);
627             $this->query_end(true);
628             if ($result === false) {
629                 return array();
630             }
631             while ($rawcolumn = $result->fetch_assoc()) {
632                 $rawcolumn = (object)array_change_key_case($rawcolumn, CASE_LOWER);
633                 $rawcolumn->column_name              = $rawcolumn->field; unset($rawcolumn->field);
634                 $rawcolumn->column_type              = $rawcolumn->type; unset($rawcolumn->type);
635                 $rawcolumn->character_maximum_length = null;
636                 $rawcolumn->numeric_precision        = null;
637                 $rawcolumn->numeric_scale            = null;
638                 $rawcolumn->is_nullable              = $rawcolumn->null; unset($rawcolumn->null);
639                 $rawcolumn->column_default           = $rawcolumn->default; unset($rawcolumn->default);
640                 $rawcolumn->column_key               = $rawcolumn->key; unset($rawcolumn->default);
642                 if (preg_match('/(enum|varchar)\((\d+)\)/i', $rawcolumn->column_type, $matches)) {
643                     $rawcolumn->data_type = $matches[1];
644                     $rawcolumn->character_maximum_length = $matches[2];
646                 } else if (preg_match('/([a-z]*int[a-z]*)\((\d+)\)/i', $rawcolumn->column_type, $matches)) {
647                     $rawcolumn->data_type = $matches[1];
648                     $rawcolumn->numeric_precision = $matches[2];
649                     $rawcolumn->max_length = $rawcolumn->numeric_precision;
651                     $type = strtoupper($matches[1]);
652                     if ($type === 'BIGINT') {
653                         $maxlength = 18;
654                     } else if ($type === 'INT' or $type === 'INTEGER') {
655                         $maxlength = 9;
656                     } else if ($type === 'MEDIUMINT') {
657                         $maxlength = 6;
658                     } else if ($type === 'SMALLINT') {
659                         $maxlength = 4;
660                     } else if ($type === 'TINYINT') {
661                         $maxlength = 2;
662                     } else {
663                         // This should not happen.
664                         $maxlength = 0;
665                     }
666                     if ($maxlength < $rawcolumn->max_length) {
667                         $rawcolumn->max_length = $maxlength;
668                     }
670                 } else if (preg_match('/(decimal)\((\d+),(\d+)\)/i', $rawcolumn->column_type, $matches)) {
671                     $rawcolumn->data_type = $matches[1];
672                     $rawcolumn->numeric_precision = $matches[2];
673                     $rawcolumn->numeric_scale = $matches[3];
675                 } else if (preg_match('/(double|float)(\((\d+),(\d+)\))?/i', $rawcolumn->column_type, $matches)) {
676                     $rawcolumn->data_type = $matches[1];
677                     $rawcolumn->numeric_precision = isset($matches[3]) ? $matches[3] : null;
678                     $rawcolumn->numeric_scale = isset($matches[4]) ? $matches[4] : null;
680                 } else if (preg_match('/([a-z]*text)/i', $rawcolumn->column_type, $matches)) {
681                     $rawcolumn->data_type = $matches[1];
682                     $rawcolumn->character_maximum_length = -1; // unknown
684                 } else if (preg_match('/([a-z]*blob)/i', $rawcolumn->column_type, $matches)) {
685                     $rawcolumn->data_type = $matches[1];
687                 } else {
688                     $rawcolumn->data_type = $rawcolumn->column_type;
689                 }
691                 $info = $this->get_column_info($rawcolumn);
692                 $structure[$info->name] = new database_column_info($info);
693             }
694             $result->close();
695         }
697         if ($usecache) {
698             if ($this->temptables->is_temptable($table)) {
699                 $this->get_temp_tables_cache()->set($table, $structure);
700             } else {
701                 $this->get_metacache()->set($table, $structure);
702             }
703         }
705         return $structure;
706     }
708     /**
709      * Returns moodle column info for raw column from information schema.
710      * @param stdClass $rawcolumn
711      * @return stdClass standardised colum info
712      */
713     private function get_column_info(stdClass $rawcolumn) {
714         $rawcolumn = (object)$rawcolumn;
715         $info = new stdClass();
716         $info->name           = $rawcolumn->column_name;
717         $info->type           = $rawcolumn->data_type;
718         $info->meta_type      = $this->mysqltype2moodletype($rawcolumn->data_type);
719         $info->default_value  = $rawcolumn->column_default;
720         $info->has_default    = !is_null($rawcolumn->column_default);
721         $info->not_null       = ($rawcolumn->is_nullable === 'NO');
722         $info->primary_key    = ($rawcolumn->column_key === 'PRI');
723         $info->binary         = false;
724         $info->unsigned       = null;
725         $info->auto_increment = false;
726         $info->unique         = null;
727         $info->scale          = null;
729         if ($info->meta_type === 'C') {
730             $info->max_length = $rawcolumn->character_maximum_length;
732         } else if ($info->meta_type === 'I') {
733             if ($info->primary_key) {
734                 $info->meta_type = 'R';
735                 $info->unique    = true;
736             }
737             // Return number of decimals, not bytes here.
738             $info->max_length    = $rawcolumn->numeric_precision;
739             if (preg_match('/([a-z]*int[a-z]*)\((\d+)\)/i', $rawcolumn->column_type, $matches)) {
740                 $type = strtoupper($matches[1]);
741                 if ($type === 'BIGINT') {
742                     $maxlength = 18;
743                 } else if ($type === 'INT' or $type === 'INTEGER') {
744                     $maxlength = 9;
745                 } else if ($type === 'MEDIUMINT') {
746                     $maxlength = 6;
747                 } else if ($type === 'SMALLINT') {
748                     $maxlength = 4;
749                 } else if ($type === 'TINYINT') {
750                     $maxlength = 2;
751                 } else {
752                     // This should not happen.
753                     $maxlength = 0;
754                 }
755                 // It is possible that display precision is different from storage type length,
756                 // always use the smaller value to make sure our data fits.
757                 if ($maxlength < $info->max_length) {
758                     $info->max_length = $maxlength;
759                 }
760             }
761             $info->unsigned      = (stripos($rawcolumn->column_type, 'unsigned') !== false);
762             $info->auto_increment= (strpos($rawcolumn->extra, 'auto_increment') !== false);
764         } else if ($info->meta_type === 'N') {
765             $info->max_length    = $rawcolumn->numeric_precision;
766             $info->scale         = $rawcolumn->numeric_scale;
767             $info->unsigned      = (stripos($rawcolumn->column_type, 'unsigned') !== false);
769         } else if ($info->meta_type === 'X') {
770             if ("$rawcolumn->character_maximum_length" === '4294967295') { // watch out for PHP max int limits!
771                 // means maximum moodle size for text column, in other drivers it may also mean unknown size
772                 $info->max_length = -1;
773             } else {
774                 $info->max_length = $rawcolumn->character_maximum_length;
775             }
776             $info->primary_key   = false;
778         } else if ($info->meta_type === 'B') {
779             $info->max_length    = -1;
780             $info->primary_key   = false;
781             $info->binary        = true;
782         }
784         return $info;
785     }
787     /**
788      * Normalise column type.
789      * @param string $mysql_type
790      * @return string one character
791      * @throws dml_exception
792      */
793     private function mysqltype2moodletype($mysql_type) {
794         $type = null;
796         switch(strtoupper($mysql_type)) {
797             case 'BIT':
798                 $type = 'L';
799                 break;
801             case 'TINYINT':
802             case 'SMALLINT':
803             case 'MEDIUMINT':
804             case 'INT':
805             case 'INTEGER':
806             case 'BIGINT':
807                 $type = 'I';
808                 break;
810             case 'FLOAT':
811             case 'DOUBLE':
812             case 'DECIMAL':
813                 $type = 'N';
814                 break;
816             case 'CHAR':
817             case 'ENUM':
818             case 'SET':
819             case 'VARCHAR':
820                 $type = 'C';
821                 break;
823             case 'TINYTEXT':
824             case 'TEXT':
825             case 'MEDIUMTEXT':
826             case 'LONGTEXT':
827                 $type = 'X';
828                 break;
830             case 'BINARY':
831             case 'VARBINARY':
832             case 'BLOB':
833             case 'TINYBLOB':
834             case 'MEDIUMBLOB':
835             case 'LONGBLOB':
836                 $type = 'B';
837                 break;
839             case 'DATE':
840             case 'TIME':
841             case 'DATETIME':
842             case 'TIMESTAMP':
843             case 'YEAR':
844                 $type = 'D';
845                 break;
846         }
848         if (!$type) {
849             throw new dml_exception('invalidmysqlnativetype', $mysql_type);
850         }
851         return $type;
852     }
854     /**
855      * Normalise values based in RDBMS dependencies (booleans, LOBs...)
856      *
857      * @param database_column_info $column column metadata corresponding with the value we are going to normalise
858      * @param mixed $value value we are going to normalise
859      * @return mixed the normalised value
860      */
861     protected function normalise_value($column, $value) {
862         $this->detect_objects($value);
864         if (is_bool($value)) { // Always, convert boolean to int
865             $value = (int)$value;
867         } else if ($value === '') {
868             if ($column->meta_type == 'I' or $column->meta_type == 'F' or $column->meta_type == 'N') {
869                 $value = 0; // prevent '' problems in numeric fields
870             }
871         // Any float value being stored in varchar or text field is converted to string to avoid
872         // any implicit conversion by MySQL
873         } else if (is_float($value) and ($column->meta_type == 'C' or $column->meta_type == 'X')) {
874             $value = "$value";
875         }
876         return $value;
877     }
879     /**
880      * Is this database compatible with utf8?
881      * @return bool
882      */
883     public function setup_is_unicodedb() {
884         // All new tables are created with this collation, we just have to make sure it is utf8 compatible,
885         // if config table already exists it has this collation too.
886         $collation = $this->get_dbcollation();
888         $sql = "SHOW COLLATION WHERE Collation ='$collation' AND Charset = 'utf8'";
889         $this->query_start($sql, NULL, SQL_QUERY_AUX);
890         $result = $this->mysqli->query($sql);
891         $this->query_end($result);
892         if ($result->fetch_assoc()) {
893             $return = true;
894         } else {
895             $return = false;
896         }
897         $result->close();
899         return $return;
900     }
902     /**
903      * Do NOT use in code, to be used by database_manager only!
904      * @param string|array $sql query
905      * @param array|null $tablenames an array of xmldb table names affected by this request.
906      * @return bool true
907      * @throws ddl_change_structure_exception A DDL specific exception is thrown for any errors.
908      */
909     public function change_database_structure($sql, $tablenames = null) {
910         $this->get_manager(); // Includes DDL exceptions classes ;-)
911         if (is_array($sql)) {
912             $sql = implode("\n;\n", $sql);
913         }
915         try {
916             $this->query_start($sql, null, SQL_QUERY_STRUCTURE);
917             $result = $this->mysqli->multi_query($sql);
918             if ($result === false) {
919                 $this->query_end(false);
920             }
921             while ($this->mysqli->more_results()) {
922                 $result = $this->mysqli->next_result();
923                 if ($result === false) {
924                     $this->query_end(false);
925                 }
926             }
927             $this->query_end(true);
928         } catch (ddl_change_structure_exception $e) {
929             while (@$this->mysqli->more_results()) {
930                 @$this->mysqli->next_result();
931             }
932             $this->reset_caches($tablenames);
933             throw $e;
934         }
936         $this->reset_caches($tablenames);
937         return true;
938     }
940     /**
941      * Very ugly hack which emulates bound parameters in queries
942      * because prepared statements do not use query cache.
943      */
944     protected function emulate_bound_params($sql, array $params=null) {
945         if (empty($params)) {
946             return $sql;
947         }
948         // ok, we have verified sql statement with ? and correct number of params
949         $parts = array_reverse(explode('?', $sql));
950         $return = array_pop($parts);
951         foreach ($params as $param) {
952             if (is_bool($param)) {
953                 $return .= (int)$param;
954             } else if (is_null($param)) {
955                 $return .= 'NULL';
956             } else if (is_number($param)) {
957                 $return .= "'".$param."'"; // we have to always use strings because mysql is using weird automatic int casting
958             } else if (is_float($param)) {
959                 $return .= $param;
960             } else {
961                 $param = $this->mysqli->real_escape_string($param);
962                 $return .= "'$param'";
963             }
964             $return .= array_pop($parts);
965         }
966         return $return;
967     }
969     /**
970      * Execute general sql query. Should be used only when no other method suitable.
971      * Do NOT use this to make changes in db structure, use database_manager methods instead!
972      * @param string $sql query
973      * @param array $params query parameters
974      * @return bool true
975      * @throws dml_exception A DML specific exception is thrown for any errors.
976      */
977     public function execute($sql, array $params=null) {
978         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
980         if (strpos($sql, ';') !== false) {
981             throw new coding_exception('moodle_database::execute() Multiple sql statements found or bound parameters not used properly in query!');
982         }
984         $rawsql = $this->emulate_bound_params($sql, $params);
986         $this->query_start($sql, $params, SQL_QUERY_UPDATE);
987         $result = $this->mysqli->query($rawsql);
988         $this->query_end($result);
990         if ($result === true) {
991             return true;
993         } else {
994             $result->close();
995             return true;
996         }
997     }
999     /**
1000      * Get a number of records as a moodle_recordset using a SQL statement.
1001      *
1002      * Since this method is a little less readable, use of it should be restricted to
1003      * code where it's possible there might be large datasets being returned.  For known
1004      * small datasets use get_records_sql - it leads to simpler code.
1005      *
1006      * The return type is like:
1007      * @see function get_recordset.
1008      *
1009      * @param string $sql the SQL select query to execute.
1010      * @param array $params array of sql parameters
1011      * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set).
1012      * @param int $limitnum return a subset comprising this many records (optional, required if $limitfrom is set).
1013      * @return moodle_recordset instance
1014      * @throws dml_exception A DML specific exception is thrown for any errors.
1015      */
1016     public function get_recordset_sql($sql, array $params=null, $limitfrom=0, $limitnum=0) {
1018         list($limitfrom, $limitnum) = $this->normalise_limit_from_num($limitfrom, $limitnum);
1020         if ($limitfrom or $limitnum) {
1021             if ($limitnum < 1) {
1022                 $limitnum = "18446744073709551615";
1023             }
1024             $sql .= " LIMIT $limitfrom, $limitnum";
1025         }
1027         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1028         $rawsql = $this->emulate_bound_params($sql, $params);
1030         $this->query_start($sql, $params, SQL_QUERY_SELECT);
1031         // no MYSQLI_USE_RESULT here, it would block write ops on affected tables
1032         $result = $this->mysqli->query($rawsql, MYSQLI_STORE_RESULT);
1033         $this->query_end($result);
1035         return $this->create_recordset($result);
1036     }
1038     /**
1039      * Get all records from a table.
1040      *
1041      * This method works around potential memory problems and may improve performance,
1042      * this method may block access to table until the recordset is closed.
1043      *
1044      * @param string $table Name of database table.
1045      * @return moodle_recordset A moodle_recordset instance {@link function get_recordset}.
1046      * @throws dml_exception A DML specific exception is thrown for any errors.
1047      */
1048     public function export_table_recordset($table) {
1049         $sql = $this->fix_table_names("SELECT * FROM {{$table}}");
1051         $this->query_start($sql, array(), SQL_QUERY_SELECT);
1052         // MYSQLI_STORE_RESULT may eat all memory for large tables, unfortunately MYSQLI_USE_RESULT blocks other queries.
1053         $result = $this->mysqli->query($sql, MYSQLI_USE_RESULT);
1054         $this->query_end($result);
1056         return $this->create_recordset($result);
1057     }
1059     protected function create_recordset($result) {
1060         return new mysqli_native_moodle_recordset($result);
1061     }
1063     /**
1064      * Get a number of records as an array of objects using a SQL statement.
1065      *
1066      * Return value is like:
1067      * @see function get_records.
1068      *
1069      * @param string $sql the SQL select query to execute. The first column of this SELECT statement
1070      *   must be a unique value (usually the 'id' field), as it will be used as the key of the
1071      *   returned array.
1072      * @param array $params array of sql parameters
1073      * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set).
1074      * @param int $limitnum return a subset comprising this many records (optional, required if $limitfrom is set).
1075      * @return array of objects, or empty array if no records were found
1076      * @throws dml_exception A DML specific exception is thrown for any errors.
1077      */
1078     public function get_records_sql($sql, array $params=null, $limitfrom=0, $limitnum=0) {
1080         list($limitfrom, $limitnum) = $this->normalise_limit_from_num($limitfrom, $limitnum);
1082         if ($limitfrom or $limitnum) {
1083             if ($limitnum < 1) {
1084                 $limitnum = "18446744073709551615";
1085             }
1086             $sql .= " LIMIT $limitfrom, $limitnum";
1087         }
1089         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1090         $rawsql = $this->emulate_bound_params($sql, $params);
1092         $this->query_start($sql, $params, SQL_QUERY_SELECT);
1093         $result = $this->mysqli->query($rawsql, MYSQLI_STORE_RESULT);
1094         $this->query_end($result);
1096         $return = array();
1098         while($row = $result->fetch_assoc()) {
1099             $row = array_change_key_case($row, CASE_LOWER);
1100             $id  = reset($row);
1101             if (isset($return[$id])) {
1102                 $colname = key($row);
1103                 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);
1104             }
1105             $return[$id] = (object)$row;
1106         }
1107         $result->close();
1109         return $return;
1110     }
1112     /**
1113      * Selects records and return values (first field) as an array using a SQL statement.
1114      *
1115      * @param string $sql The SQL query
1116      * @param array $params array of sql parameters
1117      * @return array of values
1118      * @throws dml_exception A DML specific exception is thrown for any errors.
1119      */
1120     public function get_fieldset_sql($sql, array $params=null) {
1121         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1122         $rawsql = $this->emulate_bound_params($sql, $params);
1124         $this->query_start($sql, $params, SQL_QUERY_SELECT);
1125         $result = $this->mysqli->query($rawsql, MYSQLI_STORE_RESULT);
1126         $this->query_end($result);
1128         $return = array();
1130         while($row = $result->fetch_assoc()) {
1131             $return[] = reset($row);
1132         }
1133         $result->close();
1135         return $return;
1136     }
1138     /**
1139      * Insert new record into database, as fast as possible, no safety checks, lobs not supported.
1140      * @param string $table name
1141      * @param mixed $params data record as object or array
1142      * @param bool $returnit return it of inserted record
1143      * @param bool $bulk true means repeated inserts expected
1144      * @param bool $customsequence true if 'id' included in $params, disables $returnid
1145      * @return bool|int true or new id
1146      * @throws dml_exception A DML specific exception is thrown for any errors.
1147      */
1148     public function insert_record_raw($table, $params, $returnid=true, $bulk=false, $customsequence=false) {
1149         if (!is_array($params)) {
1150             $params = (array)$params;
1151         }
1153         if ($customsequence) {
1154             if (!isset($params['id'])) {
1155                 throw new coding_exception('moodle_database::insert_record_raw() id field must be specified if custom sequences used.');
1156             }
1157             $returnid = false;
1158         } else {
1159             unset($params['id']);
1160         }
1162         if (empty($params)) {
1163             throw new coding_exception('moodle_database::insert_record_raw() no fields found.');
1164         }
1166         $fields = implode(',', array_keys($params));
1167         $qms    = array_fill(0, count($params), '?');
1168         $qms    = implode(',', $qms);
1170         $sql = "INSERT INTO {$this->prefix}$table ($fields) VALUES($qms)";
1172         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1173         $rawsql = $this->emulate_bound_params($sql, $params);
1175         $this->query_start($sql, $params, SQL_QUERY_INSERT);
1176         $result = $this->mysqli->query($rawsql);
1177         $id = @$this->mysqli->insert_id; // must be called before query_end() which may insert log into db
1178         $this->query_end($result);
1180         if (!$customsequence and !$id) {
1181             throw new dml_write_exception('unknown error fetching inserted id');
1182         }
1184         if (!$returnid) {
1185             return true;
1186         } else {
1187             return (int)$id;
1188         }
1189     }
1191     /**
1192      * Insert a record into a table and return the "id" field if required.
1193      *
1194      * Some conversions and safety checks are carried out. Lobs are supported.
1195      * If the return ID isn't required, then this just reports success as true/false.
1196      * $data is an object containing needed data
1197      * @param string $table The database table to be inserted into
1198      * @param object $data A data object with values for one or more fields in the record
1199      * @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.
1200      * @return bool|int true or new id
1201      * @throws dml_exception A DML specific exception is thrown for any errors.
1202      */
1203     public function insert_record($table, $dataobject, $returnid=true, $bulk=false) {
1204         $dataobject = (array)$dataobject;
1206         $columns = $this->get_columns($table);
1207         if (empty($columns)) {
1208             throw new dml_exception('ddltablenotexist', $table);
1209         }
1211         $cleaned = array();
1213         foreach ($dataobject as $field=>$value) {
1214             if ($field === 'id') {
1215                 continue;
1216             }
1217             if (!isset($columns[$field])) {
1218                 continue;
1219             }
1220             $column = $columns[$field];
1221             $cleaned[$field] = $this->normalise_value($column, $value);
1222         }
1224         return $this->insert_record_raw($table, $cleaned, $returnid, $bulk);
1225     }
1227     /**
1228      * Insert multiple records into database as fast as possible.
1229      *
1230      * Order of inserts is maintained, but the operation is not atomic,
1231      * use transactions if necessary.
1232      *
1233      * This method is intended for inserting of large number of small objects,
1234      * do not use for huge objects with text or binary fields.
1235      *
1236      * @since Moodle 2.7
1237      *
1238      * @param string $table  The database table to be inserted into
1239      * @param array|Traversable $dataobjects list of objects to be inserted, must be compatible with foreach
1240      * @return void does not return new record ids
1241      *
1242      * @throws coding_exception if data objects have different structure
1243      * @throws dml_exception A DML specific exception is thrown for any errors.
1244      */
1245     public function insert_records($table, $dataobjects) {
1246         if (!is_array($dataobjects) and !$dataobjects instanceof Traversable) {
1247             throw new coding_exception('insert_records() passed non-traversable object');
1248         }
1250         // MySQL has a relatively small query length limit by default,
1251         // make sure 'max_allowed_packet' in my.cnf is high enough
1252         // if you change the following default...
1253         static $chunksize = null;
1254         if ($chunksize === null) {
1255             if (!empty($this->dboptions['bulkinsertsize'])) {
1256                 $chunksize = (int)$this->dboptions['bulkinsertsize'];
1258             } else {
1259                 if (PHP_INT_SIZE === 4) {
1260                     // Bad luck for Windows, we cannot do any maths with large numbers.
1261                     $chunksize = 5;
1262                 } else {
1263                     $sql = "SHOW VARIABLES LIKE 'max_allowed_packet'";
1264                     $this->query_start($sql, null, SQL_QUERY_AUX);
1265                     $result = $this->mysqli->query($sql);
1266                     $this->query_end($result);
1267                     $size = 0;
1268                     if ($rec = $result->fetch_assoc()) {
1269                         $size = $rec['Value'];
1270                     }
1271                     $result->close();
1272                     // Hopefully 200kb per object are enough.
1273                     $chunksize = (int)($size / 200000);
1274                     if ($chunksize > 50) {
1275                         $chunksize = 50;
1276                     }
1277                 }
1278             }
1279         }
1281         $columns = $this->get_columns($table, true);
1282         $fields = null;
1283         $count = 0;
1284         $chunk = array();
1285         foreach ($dataobjects as $dataobject) {
1286             if (!is_array($dataobject) and !is_object($dataobject)) {
1287                 throw new coding_exception('insert_records() passed invalid record object');
1288             }
1289             $dataobject = (array)$dataobject;
1290             if ($fields === null) {
1291                 $fields = array_keys($dataobject);
1292                 $columns = array_intersect_key($columns, $dataobject);
1293                 unset($columns['id']);
1294             } else if ($fields !== array_keys($dataobject)) {
1295                 throw new coding_exception('All dataobjects in insert_records() must have the same structure!');
1296             }
1298             $count++;
1299             $chunk[] = $dataobject;
1301             if ($count === $chunksize) {
1302                 $this->insert_chunk($table, $chunk, $columns);
1303                 $chunk = array();
1304                 $count = 0;
1305             }
1306         }
1308         if ($count) {
1309             $this->insert_chunk($table, $chunk, $columns);
1310         }
1311     }
1313     /**
1314      * Insert records in chunks.
1315      *
1316      * Note: can be used only from insert_records().
1317      *
1318      * @param string $table
1319      * @param array $chunk
1320      * @param database_column_info[] $columns
1321      */
1322     protected function insert_chunk($table, array $chunk, array $columns) {
1323         $fieldssql = '('.implode(',', array_keys($columns)).')';
1325         $valuessql = '('.implode(',', array_fill(0, count($columns), '?')).')';
1326         $valuessql = implode(',', array_fill(0, count($chunk), $valuessql));
1328         $params = array();
1329         foreach ($chunk as $dataobject) {
1330             foreach ($columns as $field => $column) {
1331                 $params[] = $this->normalise_value($column, $dataobject[$field]);
1332             }
1333         }
1335         $sql = "INSERT INTO {$this->prefix}$table $fieldssql VALUES $valuessql";
1337         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1338         $rawsql = $this->emulate_bound_params($sql, $params);
1340         $this->query_start($sql, $params, SQL_QUERY_INSERT);
1341         $result = $this->mysqli->query($rawsql);
1342         $this->query_end($result);
1343     }
1345     /**
1346      * Import a record into a table, id field is required.
1347      * Safety checks are NOT carried out. Lobs are supported.
1348      *
1349      * @param string $table name of database table to be inserted into
1350      * @param object $dataobject A data object with values for one or more fields in the record
1351      * @return bool true
1352      * @throws dml_exception A DML specific exception is thrown for any errors.
1353      */
1354     public function import_record($table, $dataobject) {
1355         $dataobject = (array)$dataobject;
1357         $columns = $this->get_columns($table);
1358         $cleaned = array();
1360         foreach ($dataobject as $field=>$value) {
1361             if (!isset($columns[$field])) {
1362                 continue;
1363             }
1364             $cleaned[$field] = $value;
1365         }
1367         return $this->insert_record_raw($table, $cleaned, false, true, true);
1368     }
1370     /**
1371      * Update record in database, as fast as possible, no safety checks, lobs not supported.
1372      * @param string $table name
1373      * @param mixed $params data record as object or array
1374      * @param bool true means repeated updates expected
1375      * @return bool true
1376      * @throws dml_exception A DML specific exception is thrown for any errors.
1377      */
1378     public function update_record_raw($table, $params, $bulk=false) {
1379         $params = (array)$params;
1381         if (!isset($params['id'])) {
1382             throw new coding_exception('moodle_database::update_record_raw() id field must be specified.');
1383         }
1384         $id = $params['id'];
1385         unset($params['id']);
1387         if (empty($params)) {
1388             throw new coding_exception('moodle_database::update_record_raw() no fields found.');
1389         }
1391         $sets = array();
1392         foreach ($params as $field=>$value) {
1393             $sets[] = "$field = ?";
1394         }
1396         $params[] = $id; // last ? in WHERE condition
1398         $sets = implode(',', $sets);
1399         $sql = "UPDATE {$this->prefix}$table SET $sets WHERE id=?";
1401         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1402         $rawsql = $this->emulate_bound_params($sql, $params);
1404         $this->query_start($sql, $params, SQL_QUERY_UPDATE);
1405         $result = $this->mysqli->query($rawsql);
1406         $this->query_end($result);
1408         return true;
1409     }
1411     /**
1412      * Update a record in a table
1413      *
1414      * $dataobject is an object containing needed data
1415      * Relies on $dataobject having a variable "id" to
1416      * specify the record to update
1417      *
1418      * @param string $table The database table to be checked against.
1419      * @param object $dataobject An object with contents equal to fieldname=>fieldvalue. Must have an entry for 'id' to map to the table specified.
1420      * @param bool true means repeated updates expected
1421      * @return bool true
1422      * @throws dml_exception A DML specific exception is thrown for any errors.
1423      */
1424     public function update_record($table, $dataobject, $bulk=false) {
1425         $dataobject = (array)$dataobject;
1427         $columns = $this->get_columns($table);
1428         $cleaned = array();
1430         foreach ($dataobject as $field=>$value) {
1431             if (!isset($columns[$field])) {
1432                 continue;
1433             }
1434             $column = $columns[$field];
1435             $cleaned[$field] = $this->normalise_value($column, $value);
1436         }
1438         return $this->update_record_raw($table, $cleaned, $bulk);
1439     }
1441     /**
1442      * Set a single field in every table record which match a particular WHERE clause.
1443      *
1444      * @param string $table The database table to be checked against.
1445      * @param string $newfield the field to set.
1446      * @param string $newvalue the value to set the field to.
1447      * @param string $select A fragment of SQL to be used in a where clause in the SQL call.
1448      * @param array $params array of sql parameters
1449      * @return bool true
1450      * @throws dml_exception A DML specific exception is thrown for any errors.
1451      */
1452     public function set_field_select($table, $newfield, $newvalue, $select, array $params=null) {
1453         if ($select) {
1454             $select = "WHERE $select";
1455         }
1456         if (is_null($params)) {
1457             $params = array();
1458         }
1459         list($select, $params, $type) = $this->fix_sql_params($select, $params);
1461         // Get column metadata
1462         $columns = $this->get_columns($table);
1463         $column = $columns[$newfield];
1465         $normalised_value = $this->normalise_value($column, $newvalue);
1467         if (is_null($normalised_value)) {
1468             $newfield = "$newfield = NULL";
1469         } else {
1470             $newfield = "$newfield = ?";
1471             array_unshift($params, $normalised_value);
1472         }
1473         $sql = "UPDATE {$this->prefix}$table SET $newfield $select";
1474         $rawsql = $this->emulate_bound_params($sql, $params);
1476         $this->query_start($sql, $params, SQL_QUERY_UPDATE);
1477         $result = $this->mysqli->query($rawsql);
1478         $this->query_end($result);
1480         return true;
1481     }
1483     /**
1484      * Delete one or more records from a table which match a particular WHERE clause.
1485      *
1486      * @param string $table The database table to be checked against.
1487      * @param string $select A fragment of SQL to be used in a where clause in the SQL call (used to define the selection criteria).
1488      * @param array $params array of sql parameters
1489      * @return bool true
1490      * @throws dml_exception A DML specific exception is thrown for any errors.
1491      */
1492     public function delete_records_select($table, $select, array $params=null) {
1493         if ($select) {
1494             $select = "WHERE $select";
1495         }
1496         $sql = "DELETE FROM {$this->prefix}$table $select";
1498         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1499         $rawsql = $this->emulate_bound_params($sql, $params);
1501         $this->query_start($sql, $params, SQL_QUERY_UPDATE);
1502         $result = $this->mysqli->query($rawsql);
1503         $this->query_end($result);
1505         return true;
1506     }
1508     public function sql_cast_char2int($fieldname, $text=false) {
1509         return ' CAST(' . $fieldname . ' AS SIGNED) ';
1510     }
1512     public function sql_cast_char2real($fieldname, $text=false) {
1513         // Set to 65 (max mysql 5.5 precision) with 7 as scale
1514         // because we must ensure at least 6 decimal positions
1515         // per casting given that postgres is casting to that scale (::real::).
1516         // Can be raised easily but that must be done in all DBs and tests.
1517         return ' CAST(' . $fieldname . ' AS DECIMAL(65,7)) ';
1518     }
1520     public function sql_equal($fieldname, $param, $casesensitive = true, $accentsensitive = true, $notequal = false) {
1521         $equalop = $notequal ? '<>' : '=';
1522         if ($casesensitive) {
1523             // Current MySQL versions do not support case sensitive and accent insensitive.
1524             return "$fieldname COLLATE utf8_bin $equalop $param";
1525         } else if ($accentsensitive) {
1526             // Case insensitive and accent sensitive, we can force a binary comparison once all texts are using the same case.
1527             return "LOWER($fieldname) COLLATE utf8_bin $equalop LOWER($param)";
1528         } else {
1529             // Case insensitive and accent insensitive. All collations are that way, but utf8_bin.
1530             $collation = '';
1531             if ($this->get_dbcollation() == 'utf8_bin') {
1532                 $collation = 'COLLATE utf8_unicode_ci';
1533             }
1534             return "$fieldname $collation $equalop $param";
1535         }
1536     }
1538     /**
1539      * Returns 'LIKE' part of a query.
1540      *
1541      * Note that mysql does not support $casesensitive = true and $accentsensitive = false.
1542      * More information in http://bugs.mysql.com/bug.php?id=19567.
1543      *
1544      * @param string $fieldname usually name of the table column
1545      * @param string $param usually bound query parameter (?, :named)
1546      * @param bool $casesensitive use case sensitive search
1547      * @param bool $accensensitive use accent sensitive search (ignored if $casesensitive is true)
1548      * @param bool $notlike true means "NOT LIKE"
1549      * @param string $escapechar escape char for '%' and '_'
1550      * @return string SQL code fragment
1551      */
1552     public function sql_like($fieldname, $param, $casesensitive = true, $accentsensitive = true, $notlike = false, $escapechar = '\\') {
1553         if (strpos($param, '%') !== false) {
1554             debugging('Potential SQL injection detected, sql_like() expects bound parameters (? or :named)');
1555         }
1556         $escapechar = $this->mysqli->real_escape_string($escapechar); // prevents problems with C-style escapes of enclosing '\'
1558         $LIKE = $notlike ? 'NOT LIKE' : 'LIKE';
1560         if ($casesensitive) {
1561             // Current MySQL versions do not support case sensitive and accent insensitive.
1562             return "$fieldname $LIKE $param COLLATE utf8_bin ESCAPE '$escapechar'";
1564         } else if ($accentsensitive) {
1565             // Case insensitive and accent sensitive, we can force a binary comparison once all texts are using the same case.
1566             return "LOWER($fieldname) $LIKE LOWER($param) COLLATE utf8_bin ESCAPE '$escapechar'";
1568         } else {
1569             // Case insensitive and accent insensitive.
1570             $collation = '';
1571             if ($this->get_dbcollation() == 'utf8_bin') {
1572                 // Force a case insensitive comparison if using utf8_bin.
1573                 $collation = 'COLLATE utf8_unicode_ci';
1574             }
1576             return "$fieldname $LIKE $param $collation ESCAPE '$escapechar'";
1577         }
1578     }
1580     /**
1581      * Returns the proper SQL to do CONCAT between the elements passed
1582      * Can take many parameters
1583      *
1584      * @param string $str,... 1 or more fields/strings to concat
1585      *
1586      * @return string The concat sql
1587      */
1588     public function sql_concat() {
1589         $arr = func_get_args();
1590         $s = implode(', ', $arr);
1591         if ($s === '') {
1592             return "''";
1593         }
1594         return "CONCAT($s)";
1595     }
1597     /**
1598      * Returns the proper SQL to do CONCAT between the elements passed
1599      * with a given separator
1600      *
1601      * @param string $separator The string to use as the separator
1602      * @param array $elements An array of items to concatenate
1603      * @return string The concat SQL
1604      */
1605     public function sql_concat_join($separator="' '", $elements=array()) {
1606         $s = implode(', ', $elements);
1608         if ($s === '') {
1609             return "''";
1610         }
1611         return "CONCAT_WS($separator, $s)";
1612     }
1614     /**
1615      * Returns the SQL text to be used to calculate the length in characters of one expression.
1616      * @param string fieldname or expression to calculate its length in characters.
1617      * @return string the piece of SQL code to be used in the statement.
1618      */
1619     public function sql_length($fieldname) {
1620         return ' CHAR_LENGTH(' . $fieldname . ')';
1621     }
1623     /**
1624      * Does this driver support regex syntax when searching
1625      */
1626     public function sql_regex_supported() {
1627         return true;
1628     }
1630     /**
1631      * Return regex positive or negative match sql
1632      * @param bool $positivematch
1633      * @return string or empty if not supported
1634      */
1635     public function sql_regex($positivematch=true) {
1636         return $positivematch ? 'REGEXP' : 'NOT REGEXP';
1637     }
1639     /**
1640      * Returns the SQL to be used in order to an UNSIGNED INTEGER column to SIGNED.
1641      *
1642      * @deprecated since 2.3
1643      * @param string $fieldname The name of the field to be cast
1644      * @return string The piece of SQL code to be used in your statement.
1645      */
1646     public function sql_cast_2signed($fieldname) {
1647         return ' CAST(' . $fieldname . ' AS SIGNED) ';
1648     }
1650     /**
1651      * Returns the SQL that allows to find intersection of two or more queries
1652      *
1653      * @since Moodle 2.8
1654      *
1655      * @param array $selects array of SQL select queries, each of them only returns fields with the names from $fields
1656      * @param string $fields comma-separated list of fields
1657      * @return string SQL query that will return only values that are present in each of selects
1658      */
1659     public function sql_intersect($selects, $fields) {
1660         if (count($selects) <= 1) {
1661             return parent::sql_intersect($selects, $fields);
1662         }
1663         $fields = preg_replace('/\s/', '', $fields);
1664         static $aliascnt = 0;
1665         $falias = 'intsctal'.($aliascnt++);
1666         $rv = "SELECT $falias.".
1667             preg_replace('/,/', ','.$falias.'.', $fields).
1668             " FROM ($selects[0]) $falias";
1669         for ($i = 1; $i < count($selects); $i++) {
1670             $alias = 'intsctal'.($aliascnt++);
1671             $rv .= " JOIN (".$selects[$i].") $alias ON ".
1672                 join(' AND ',
1673                     array_map(
1674                         create_function('$a', 'return "'.$falias.'.$a = '.$alias.'.$a";'),
1675                         preg_split('/,/', $fields))
1676                 );
1677         }
1678         return $rv;
1679     }
1681     /**
1682      * Does this driver support tool_replace?
1683      *
1684      * @since Moodle 2.6.1
1685      * @return bool
1686      */
1687     public function replace_all_text_supported() {
1688         return true;
1689     }
1691     public function session_lock_supported() {
1692         return true;
1693     }
1695     /**
1696      * Obtain session lock
1697      * @param int $rowid id of the row with session record
1698      * @param int $timeout max allowed time to wait for the lock in seconds
1699      * @return void
1700      */
1701     public function get_session_lock($rowid, $timeout) {
1702         parent::get_session_lock($rowid, $timeout);
1704         $fullname = $this->dbname.'-'.$this->prefix.'-session-'.$rowid;
1705         $sql = "SELECT GET_LOCK('$fullname', $timeout)";
1706         $this->query_start($sql, null, SQL_QUERY_AUX);
1707         $result = $this->mysqli->query($sql);
1708         $this->query_end($result);
1710         if ($result) {
1711             $arr = $result->fetch_assoc();
1712             $result->close();
1714             if (reset($arr) == 1) {
1715                 return;
1716             } else {
1717                 throw new dml_sessionwait_exception();
1718             }
1719         }
1720     }
1722     public function release_session_lock($rowid) {
1723         if (!$this->used_for_db_sessions) {
1724             return;
1725         }
1727         parent::release_session_lock($rowid);
1728         $fullname = $this->dbname.'-'.$this->prefix.'-session-'.$rowid;
1729         $sql = "SELECT RELEASE_LOCK('$fullname')";
1730         $this->query_start($sql, null, SQL_QUERY_AUX);
1731         $result = $this->mysqli->query($sql);
1732         $this->query_end($result);
1734         if ($result) {
1735             $result->close();
1736         }
1737     }
1739     /**
1740      * Are transactions supported?
1741      * It is not responsible to run productions servers
1742      * on databases without transaction support ;-)
1743      *
1744      * MyISAM does not support support transactions.
1745      *
1746      * You can override this via the dbtransactions option.
1747      *
1748      * @return bool
1749      */
1750     protected function transactions_supported() {
1751         if (!is_null($this->transactions_supported)) {
1752             return $this->transactions_supported;
1753         }
1755         // this is all just guessing, might be better to just specify it in config.php
1756         if (isset($this->dboptions['dbtransactions'])) {
1757             $this->transactions_supported = $this->dboptions['dbtransactions'];
1758             return $this->transactions_supported;
1759         }
1761         $this->transactions_supported = false;
1763         $engine = $this->get_dbengine();
1765         // Only will accept transactions if using compatible storage engine (more engines can be added easily BDB, Falcon...)
1766         if (in_array($engine, array('InnoDB', 'INNOBASE', 'BDB', 'XtraDB', 'Aria', 'Falcon'))) {
1767             $this->transactions_supported = true;
1768         }
1770         return $this->transactions_supported;
1771     }
1773     /**
1774      * Driver specific start of real database transaction,
1775      * this can not be used directly in code.
1776      * @return void
1777      */
1778     protected function begin_transaction() {
1779         if (!$this->transactions_supported()) {
1780             return;
1781         }
1783         $sql = "SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED";
1784         $this->query_start($sql, NULL, SQL_QUERY_AUX);
1785         $result = $this->mysqli->query($sql);
1786         $this->query_end($result);
1788         $sql = "START TRANSACTION";
1789         $this->query_start($sql, NULL, SQL_QUERY_AUX);
1790         $result = $this->mysqli->query($sql);
1791         $this->query_end($result);
1792     }
1794     /**
1795      * Driver specific commit of real database transaction,
1796      * this can not be used directly in code.
1797      * @return void
1798      */
1799     protected function commit_transaction() {
1800         if (!$this->transactions_supported()) {
1801             return;
1802         }
1804         $sql = "COMMIT";
1805         $this->query_start($sql, NULL, SQL_QUERY_AUX);
1806         $result = $this->mysqli->query($sql);
1807         $this->query_end($result);
1808     }
1810     /**
1811      * Driver specific abort of real database transaction,
1812      * this can not be used directly in code.
1813      * @return void
1814      */
1815     protected function rollback_transaction() {
1816         if (!$this->transactions_supported()) {
1817             return;
1818         }
1820         $sql = "ROLLBACK";
1821         $this->query_start($sql, NULL, SQL_QUERY_AUX);
1822         $result = $this->mysqli->query($sql);
1823         $this->query_end($result);
1825         return true;
1826     }