lib/dml/mysqli_native_moodle_database.php

   1 <?php
   2
   3 // This file is part of Moodle - http://moodle.org/
   4 //
   5 // Moodle is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // Moodle is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  17
  18
  19 /**
  20  * Native mysqli class representing moodle database interface.
  21  *
  22  * @package    core
  23  * @subpackage dml
  24  * @copyright  2008 Petr Skoda (http://skodak.org)
  25  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  26  */
  27
  28 defined('MOODLE_INTERNAL') || die();
  29
  30 require_once($CFG->libdir.'/dml/moodle_database.php');
  31 require_once($CFG->libdir.'/dml/mysqli_native_moodle_recordset.php');
  32 require_once($CFG->libdir.'/dml/mysqli_native_moodle_temptables.php');
  33
  34 /**
  35  * Native mysqli class representing moodle database interface.
  36  */
  37 class mysqli_native_moodle_database extends moodle_database {
  38
  39     protected $mysqli = null;
  40
  41     private $transactions_supported = null;
  42
  43     /**
  44      * Attempt to create the database
  45      * @param string $dbhost
  46      * @param string $dbuser
  47      * @param string $dbpass
  48      * @param string $dbname
  49      * @return bool success
  50      * @throws dml_exception if error
  51      */
  52     public function create_database($dbhost, $dbuser, $dbpass, $dbname, array $dboptions=null) {
  53         $driverstatus = $this->driver_installed();
  54
  55         if ($driverstatus !== true) {
  56             throw new dml_exception('dbdriverproblem', $driverstatus);
  57         }
  58
  59         if (!empty($dboptions['dbsocket'])
  60                 and (strpos($dboptions['dbsocket'], '/') !== false or strpos($dboptions['dbsocket'], '\\') !== false)) {
  61             $dbsocket = $dboptions['dbsocket'];
  62         } else {
  63             $dbsocket = ini_get('mysqli.default_socket');
  64         }
  65         if (empty($dboptions['dbport'])) {
  66             $dbport = (int)ini_get('mysqli.default_port');
  67         } else {
  68             $dbport = (int)$dboptions['dbport'];
  69         }
  70         // verify ini.get does not return nonsense
  71         if (empty($dbport)) {
  72             $dbport = 3306;
  73         }
  74         ob_start();
  75         $conn = new mysqli($dbhost, $dbuser, $dbpass, '', $dbport, $dbsocket); /// Connect without db
  76         $dberr = ob_get_contents();
  77         ob_end_clean();
  78         $errorno = @$conn->connect_errno;
  79
  80         if ($errorno !== 0) {
  81             throw new dml_connection_exception($dberr);
  82         }
  83
  84         $result = $conn->query("CREATE DATABASE $dbname DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci");
  85
  86         $conn->close();
  87
  88         if (!$result) {
  89             throw new dml_exception('cannotcreatedb');
  90         }
  91
  92         return true;
  93     }
  94
  95     /**
  96      * Detects if all needed PHP stuff installed.
  97      * Note: can be used before connect()
  98      * @return mixed true if ok, string if something
  99      */
 100     public function driver_installed() {
 101         if (!extension_loaded('mysqli')) {
 102             return get_string('mysqliextensionisnotpresentinphp', 'install');
 103         }
 104         return true;
 105     }
 106
 107     /**
 108      * Returns database family type - describes SQL dialect
 109      * Note: can be used before connect()
 110      * @return string db family name (mysql, postgres, mssql, oracle, etc.)
 111      */
 112     public function get_dbfamily() {
 113         return 'mysql';
 114     }
 115
 116     /**
 117      * Returns more specific database driver type
 118      * Note: can be used before connect()
 119      * @return string db type mysqli, pgsql, oci, mssql, sqlsrv
 120      */
 121     protected function get_dbtype() {
 122         return 'mysqli';
 123     }
 124
 125     /**
 126      * Returns general database library name
 127      * Note: can be used before connect()
 128      * @return string db type pdo, native
 129      */
 130     protected function get_dblibrary() {
 131         return 'native';
 132     }
 133
 134     /**
 135      * Returns the current MySQL db engine.
 136      *
 137      * This is an ugly workaround for MySQL default engine problems,
 138      * Moodle is designed to work best on ACID compliant databases
 139      * with full transaction support. Do not use MyISAM.
 140      *
 141      * @return string or null MySQL engine name
 142      */
 143     public function get_dbengine() {
 144         if (isset($this->dboptions['dbengine'])) {
 145             return $this->dboptions['dbengine'];
 146         }
 147
 148         $engine = null;
 149
 150         if (!$this->external) {
 151             // look for current engine of our config table (the first table that gets created),
 152             // so that we create all tables with the same engine
 153             $sql = "SELECT engine FROM INFORMATION_SCHEMA.TABLES WHERE table_schema = DATABASE() AND table_name = '{$this->prefix}config'";
 154             $this->query_start($sql, NULL, SQL_QUERY_AUX);
 155             $result = $this->mysqli->query($sql);
 156             $this->query_end($result);
 157             if ($rec = $result->fetch_assoc()) {
 158                 $engine = $rec['engine'];
 159             }
 160             $result->close();
 161         }
 162
 163         if ($engine) {
 164             return $engine;
 165         }
 166
 167         // get the default database engine
 168         $sql = "SELECT @@storage_engine";
 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['@@storage_engine'];
 174         }
 175         $result->close();
 176
 177         if (!$this->external and $engine === 'MyISAM') {
 178             // we really do not want MyISAM for Moodle, InnoDB or XtraDB is a reasonable defaults if supported
 179             $sql = "SHOW STORAGE ENGINES";
 180             $this->query_start($sql, NULL, SQL_QUERY_AUX);
 181             $result = $this->mysqli->query($sql);
 182             $this->query_end($result);
 183             $engines = array();
 184             while ($res = $result->fetch_assoc()) {
 185                 if ($res['Support'] === 'YES' or $res['Support'] === 'DEFAULT') {
 186                     $engines[$res['Engine']] = true;
 187                 }
 188             }
 189             $result->close();
 190             if (isset($engines['InnoDB'])) {
 191                 $engine = 'InnoDB';
 192             }
 193             if (isset($engines['XtraDB'])) {
 194                 $engine = 'XtraDB';
 195             }
 196         }
 197
 198         return $engine;
 199     }
 200
 201     /**
 202      * Returns localised database type name
 203      * Note: can be used before connect()
 204      * @return string
 205      */
 206     public function get_name() {
 207         return get_string('nativemysqli', 'install');
 208     }
 209
 210     /**
 211      * Returns localised database configuration help.
 212      * Note: can be used before connect()
 213      * @return string
 214      */
 215     public function get_configuration_help() {
 216         return get_string('nativemysqlihelp', 'install');
 217     }
 218
 219     /**
 220      * Returns localised database description
 221      * Note: can be used before connect()
 222      * @return string
 223      */
 224     public function get_configuration_hints() {
 225         return get_string('databasesettingssub_mysqli', 'install');
 226     }
 227
 228     /**
 229      * Diagnose database and tables, this function is used
 230      * to verify database and driver settings, db engine types, etc.
 231      *
 232      * @return string null means everything ok, string means problem found.
 233      */
 234     public function diagnose() {
 235         $sloppymyisamfound = false;
 236         $prefix = str_replace('_', '\\_', $this->prefix);
 237         $sql = "SHOW TABLE STATUS WHERE Name LIKE BINARY '$prefix%'";
 238         $this->query_start($sql, null, SQL_QUERY_AUX);
 239         $result = $this->mysqli->query($sql);
 240         $this->query_end($result);
 241         if ($result) {
 242             while ($arr = $result->fetch_assoc()) {
 243                 if ($arr['Engine'] === 'MyISAM') {
 244                     $sloppymyisamfound = true;
 245                     break;
 246                 }
 247             }
 248             $result->close();
 249         }
 250
 251         if ($sloppymyisamfound) {
 252             return get_string('myisamproblem', 'error');
 253         } else {
 254             return null;
 255         }
 256     }
 257
 258     /**
 259      * Connect to db
 260      * Must be called before other methods.
 261      * @param string $dbhost
 262      * @param string $dbuser
 263      * @param string $dbpass
 264      * @param string $dbname
 265      * @param mixed $prefix string means moodle db prefix, false used for external databases where prefix not used
 266      * @param array $dboptions driver specific options
 267      * @return bool success
 268      */
 269     public function connect($dbhost, $dbuser, $dbpass, $dbname, $prefix, array $dboptions=null) {
 270         $driverstatus = $this->driver_installed();
 271
 272         if ($driverstatus !== true) {
 273             throw new dml_exception('dbdriverproblem', $driverstatus);
 274         }
 275
 276         $this->store_settings($dbhost, $dbuser, $dbpass, $dbname, $prefix, $dboptions);
 277
 278         // dbsocket is used ONLY if host is NULL or 'localhost',
 279         // you can not disable it because it is always tried if dbhost is 'localhost'
 280         if (!empty($this->dboptions['dbsocket'])
 281                 and (strpos($this->dboptions['dbsocket'], '/') !== false or strpos($this->dboptions['dbsocket'], '\\') !== false)) {
 282             $dbsocket = $this->dboptions['dbsocket'];
 283         } else {
 284             $dbsocket = ini_get('mysqli.default_socket');
 285         }
 286         if (empty($this->dboptions['dbport'])) {
 287             $dbport = (int)ini_get('mysqli.default_port');
 288         } else {
 289             $dbport = (int)$this->dboptions['dbport'];
 290         }
 291         // verify ini.get does not return nonsense
 292         if (empty($dbport)) {
 293             $dbport = 3306;
 294         }
 295         ob_start();
 296         $this->mysqli = new mysqli($dbhost, $dbuser, $dbpass, $dbname, $dbport, $dbsocket);
 297         $dberr = ob_get_contents();
 298         ob_end_clean();
 299         $errorno = @$this->mysqli->connect_errno;
 300
 301         if ($errorno !== 0) {
 302             throw new dml_connection_exception($dberr);
 303         }
 304
 305         $this->query_start("--set_charset()", null, SQL_QUERY_AUX);
 306         $this->mysqli->set_charset('utf8');
 307         $this->query_end(true);
 308
 309         // If available, enforce strict mode for the session. That guaranties
 310         // standard behaviour under some situations, avoiding some MySQL nasty
 311         // habits like truncating data or performing some transparent cast losses.
 312         // With strict mode enforced, Moodle DB layer will be consistently throwing
 313         // the corresponding exceptions as expected.
 314         $si = $this->get_server_info();
 315         if (version_compare($si['version'], '5.0.2', '>=')) {
 316             $sql = "SET SESSION sql_mode = 'STRICT_ALL_TABLES'";
 317             $this->query_start($sql, null, SQL_QUERY_AUX);
 318             $result = $this->mysqli->query($sql);
 319             $this->query_end($result);
 320         }
 321
 322         // Connection stabilished and configured, going to instantiate the temptables controller
 323         $this->temptables = new mysqli_native_moodle_temptables($this);
 324
 325         return true;
 326     }
 327
 328     /**
 329      * Close database connection and release all resources
 330      * and memory (especially circular memory references).
 331      * Do NOT use connect() again, create a new instance if needed.
 332      */
 333     public function dispose() {
 334         parent::dispose(); // Call parent dispose to write/close session and other common stuff before closing connection
 335         if ($this->mysqli) {
 336             $this->mysqli->close();
 337             $this->mysqli = null;
 338         }
 339     }
 340
 341     /**
 342      * Returns database server info array
 343      * @return array
 344      */
 345     public function get_server_info() {
 346         return array('description'=>$this->mysqli->server_info, 'version'=>$this->mysqli->server_info);
 347     }
 348
 349     /**
 350      * Returns supported query parameter types
 351      * @return int bitmask
 352      */
 353     protected function allowed_param_types() {
 354         return SQL_PARAMS_QM;
 355     }
 356
 357     /**
 358      * Returns last error reported by database engine.
 359      * @return string error message
 360      */
 361     public function get_last_error() {
 362         return $this->mysqli->error;
 363     }
 364
 365     /**
 366      * Return tables in database WITHOUT current prefix
 367      * @return array of table names in lowercase and without prefix
 368      */
 369     public function get_tables($usecache=true) {
 370         if ($usecache and $this->tables !== null) {
 371             return $this->tables;
 372         }
 373         $this->tables = array();
 374         $sql = "SHOW TABLES";
 375         $this->query_start($sql, null, SQL_QUERY_AUX);
 376         $result = $this->mysqli->query($sql);
 377         $this->query_end($result);
 378         if ($result) {
 379             while ($arr = $result->fetch_assoc()) {
 380                 $tablename = reset($arr);
 381                 if ($this->prefix !== '') {
 382                     if (strpos($tablename, $this->prefix) !== 0) {
 383                         continue;
 384                     }
 385                     $tablename = substr($tablename, strlen($this->prefix));
 386                 }
 387                 $this->tables[$tablename] = $tablename;
 388             }
 389             $result->close();
 390         }
 391
 392         // Add the currently available temptables
 393         $this->tables = array_merge($this->tables, $this->temptables->get_temptables());
 394         return $this->tables;
 395     }
 396
 397     /**
 398      * Return table indexes - everything lowercased
 399      * @return array of arrays
 400      */
 401     public function get_indexes($table) {
 402         $indexes = array();
 403         $sql = "SHOW INDEXES FROM {$this->prefix}$table";
 404         $this->query_start($sql, null, SQL_QUERY_AUX);
 405         $result = $this->mysqli->query($sql);
 406         $this->query_end($result);
 407         if ($result) {
 408             while ($res = $result->fetch_object()) {
 409                 if ($res->Key_name === 'PRIMARY') {
 410                     continue;
 411                 }
 412                 if (!isset($indexes[$res->Key_name])) {
 413                     $indexes[$res->Key_name] = array('unique'=>empty($res->Non_unique), 'columns'=>array());
 414                 }
 415                 $indexes[$res->Key_name]['columns'][$res->Seq_in_index-1] = $res->Column_name;
 416             }
 417             $result->close();
 418         }
 419         return $indexes;
 420     }
 421
 422     /**
 423      * Returns detailed information about columns in table. This information is cached internally.
 424      * @param string $table name
 425      * @param bool $usecache
 426      * @return array array of database_column_info objects indexed with column names
 427      */
 428     public function get_columns($table, $usecache=true) {
 429         if ($usecache and isset($this->columns[$table])) {
 430             return $this->columns[$table];
 431         }
 432
 433         $this->columns[$table] = array();
 434
 435         $sql = "SHOW COLUMNS FROM {$this->prefix}$table";
 436         $this->query_start($sql, null, SQL_QUERY_AUX);
 437         $result = $this->mysqli->query($sql);
 438         $this->query_end($result);
 439
 440         if ($result === false) {
 441             return array();
 442         }
 443
 444         while ($rawcolumn = $result->fetch_assoc()) {
 445             $rawcolumn = (object)array_change_key_case($rawcolumn, CASE_LOWER);
 446
 447             $info = new stdClass();
 448             $info->name = $rawcolumn->field;
 449             $matches = null;
 450
 451             if (preg_match('/varchar\((\d+)\)/i', $rawcolumn->type, $matches)) {
 452                 $info->type          = 'varchar';
 453                 $info->meta_type     = 'C';
 454                 $info->max_length    = $matches[1];
 455                 $info->scale         = null;
 456                 $info->not_null      = ($rawcolumn->null === 'NO');
 457                 $info->default_value = $rawcolumn->default;
 458                 $info->has_default   = is_null($info->default_value) ? false : true;
 459                 $info->primary_key   = ($rawcolumn->key === 'PRI');
 460                 $info->binary        = false;
 461                 $info->unsigned      = null;
 462                 $info->auto_increment= false;
 463                 $info->unique        = null;
 464
 465             } else if (preg_match('/([a-z]*int[a-z]*)\((\d+)\)/i', $rawcolumn->type, $matches)) {
 466                 $info->type = $matches[1];
 467                 $info->primary_key       = ($rawcolumn->key === 'PRI');
 468                 if ($info->primary_key) {
 469                     $info->meta_type     = 'R';
 470                     $info->max_length    = $matches[2];
 471                     $info->scale         = null;
 472                     $info->not_null      = ($rawcolumn->null === 'NO');
 473                     $info->default_value = $rawcolumn->default;
 474                     $info->has_default   = is_null($info->default_value) ? false : true;
 475                     $info->binary        = false;
 476                     $info->unsigned      = (stripos($rawcolumn->type, 'unsigned') !== false);
 477                     $info->auto_increment= true;
 478                     $info->unique        = true;
 479                 } else {
 480                     $info->meta_type     = 'I';
 481                     $info->max_length    = $matches[2];
 482                     $info->scale         = null;
 483                     $info->not_null      = ($rawcolumn->null === 'NO');
 484                     $info->default_value = $rawcolumn->default;
 485                     $info->has_default   = is_null($info->default_value) ? false : true;
 486                     $info->binary        = false;
 487                     $info->unsigned      = (stripos($rawcolumn->type, 'unsigned') !== false);
 488                     $info->auto_increment= false;
 489                     $info->unique        = null;
 490                 }
 491
 492             } else if (preg_match('/(decimal|double|float)\((\d+),(\d+)\)/i', $rawcolumn->type, $matches)) {
 493                 $info->type          = $matches[1];
 494                 $info->meta_type     = 'N';
 495                 $info->max_length    = $matches[2];
 496                 $info->scale         = $matches[3];
 497                 $info->not_null      = ($rawcolumn->null === 'NO');
 498                 $info->default_value = $rawcolumn->default;
 499                 $info->has_default   = is_null($info->default_value) ? false : true;
 500                 $info->primary_key   = ($rawcolumn->key === 'PRI');
 501                 $info->binary        = false;
 502                 $info->unsigned      = (stripos($rawcolumn->type, 'unsigned') !== false);
 503                 $info->auto_increment= false;
 504                 $info->unique        = null;
 505
 506             } else if (preg_match('/([a-z]*text)/i', $rawcolumn->type, $matches)) {
 507                 $info->type          = $matches[1];
 508                 $info->meta_type     = 'X';
 509                 $info->max_length    = -1;
 510                 $info->scale         = null;
 511                 $info->not_null      = ($rawcolumn->null === 'NO');
 512                 $info->default_value = $rawcolumn->default;
 513                 $info->has_default   = is_null($info->default_value) ? false : true;
 514                 $info->primary_key   = ($rawcolumn->key === 'PRI');
 515                 $info->binary        = false;
 516                 $info->unsigned      = null;
 517                 $info->auto_increment= false;
 518                 $info->unique        = null;
 519
 520             } else if (preg_match('/([a-z]*blob)/i', $rawcolumn->type, $matches)) {
 521                 $info->type          = $matches[1];
 522                 $info->meta_type     = 'B';
 523                 $info->max_length    = -1;
 524                 $info->scale         = null;
 525                 $info->not_null      = ($rawcolumn->null === 'NO');
 526                 $info->default_value = $rawcolumn->default;
 527                 $info->has_default   = is_null($info->default_value) ? false : true;
 528                 $info->primary_key   = false;
 529                 $info->binary        = true;
 530                 $info->unsigned      = null;
 531                 $info->auto_increment= false;
 532                 $info->unique        = null;
 533
 534             } else if (preg_match('/enum\((.*)\)/i', $rawcolumn->type, $matches)) {
 535                 $info->type          = 'enum';
 536                 $info->meta_type     = 'C';
 537                 $info->enums         = array();
 538                 $info->max_length    = 0;
 539                 $values = $matches[1];
 540                 $values = explode(',', $values);
 541                 $textlib = textlib_get_instance();
 542                 foreach ($values as $val) {
 543                     $val = trim($val, "'");
 544                     $length = $textlib->strlen($val);
 545                     $info->enums[] = $val;
 546                     $info->max_length = ($info->max_length < $length) ? $length : $info->max_length;
 547                 }
 548                 $info->scale         = null;
 549                 $info->not_null      = ($rawcolumn->null === 'NO');
 550                 $info->default_value = $rawcolumn->default;
 551                 $info->has_default   = is_null($info->default_value) ? false : true;
 552                 $info->primary_key   = ($rawcolumn->key === 'PRI');
 553                 $info->binary        = false;
 554                 $info->unsigned      = null;
 555                 $info->auto_increment= false;
 556                 $info->unique        = null;
 557             }
 558
 559             $this->columns[$table][$info->name] = new database_column_info($info);
 560         }
 561
 562         $result->close();
 563
 564         return $this->columns[$table];
 565     }
 566
 567     /**
 568      * Normalise values based in RDBMS dependencies (booleans, LOBs...)
 569      *
 570      * @param database_column_info $column column metadata corresponding with the value we are going to normalise
 571      * @param mixed $value value we are going to normalise
 572      * @return mixed the normalised value
 573      */
 574     protected function normalise_value($column, $value) {
 575         if (is_bool($value)) { // Always, convert boolean to int
 576             $value = (int)$value;
 577
 578         } else if ($value === '') {
 579             if ($column->meta_type == 'I' or $column->meta_type == 'F' or $column->meta_type == 'N') {
 580                 $value = 0; // prevent '' problems in numeric fields
 581             }
 582         // Any float value being stored in varchar or text field is converted to string to avoid
 583         // any implicit conversion by MySQL
 584         } else if (is_float($value) and ($column->meta_type == 'C' or $column->meta_type == 'X')) {
 585             $value = "$value";
 586         }
 587         // workaround for problem with wrong enums in mysql - TODO: Out in Moodle 2.1
 588         if (!empty($column->enums)) {
 589             if (is_null($value) and !$column->not_null) {
 590                 // ok - nulls allowed
 591             } else {
 592                 if (!in_array((string)$value, $column->enums)) {
 593                     throw new dml_write_exception('Enum value '.s($value).' not allowed in field '.$field.' table '.$table.'.');
 594                 }
 595             }
 596         }
 597         return $value;
 598     }
 599
 600     /**
 601      * Is db in unicode mode?
 602      * @return bool
 603      */
 604     public function setup_is_unicodedb() {
 605         $sql = "SHOW LOCAL VARIABLES LIKE 'character_set_database'";
 606         $this->query_start($sql, null, SQL_QUERY_AUX);
 607         $result = $this->mysqli->query($sql);
 608         $this->query_end($result);
 609
 610         $return = false;
 611         if ($result) {
 612             while($row = $result->fetch_assoc()) {
 613                 if (isset($row['Value'])) {
 614                     $return = (strtoupper($row['Value']) === 'UTF8' or strtoupper($row['Value']) === 'UTF-8');
 615                 }
 616                 break;
 617             }
 618             $result->close();
 619         }
 620
 621         if (!$return) {
 622             return false;
 623         }
 624
 625         $sql = "SHOW LOCAL VARIABLES LIKE 'collation_database'";
 626         $this->query_start($sql, null, SQL_QUERY_AUX);
 627         $result = $this->mysqli->query($sql);
 628         $this->query_end($result);
 629
 630         $return = false;
 631         if ($result) {
 632             while($row = $result->fetch_assoc()) {
 633                 if (isset($row['Value'])) {
 634                     $return = (strpos($row['Value'], 'latin1') !== 0);
 635                 }
 636                 break;
 637             }
 638             $result->close();
 639         }
 640
 641         return $return;
 642     }
 643
 644     /**
 645      * Do NOT use in code, to be used by database_manager only!
 646      * @param string $sql query
 647      * @return bool true
 648      * @throws dml_exception if error
 649      */
 650     public function change_database_structure($sql) {
 651         $this->reset_caches();
 652
 653         $this->query_start($sql, null, SQL_QUERY_STRUCTURE);
 654         $result = $this->mysqli->query($sql);
 655         $this->query_end($result);
 656
 657         return true;
 658     }
 659
 660     /**
 661      * Very ugly hack which emulates bound parameters in queries
 662      * because prepared statements do not use query cache.
 663      */
 664     protected function emulate_bound_params($sql, array $params=null) {
 665         if (empty($params)) {
 666             return $sql;
 667         }
 668         /// ok, we have verified sql statement with ? and correct number of params
 669         $return = strtok($sql, '?');
 670         foreach ($params as $param) {
 671             if (is_bool($param)) {
 672                 $return .= (int)$param;
 673             } else if (is_null($param)) {
 674                 $return .= 'NULL';
 675             } else if (is_number($param)) {
 676                 $return .= "'".$param."'"; // we have to always use strings because mysql is using weird automatic int casting
 677             } else if (is_float($param)) {
 678                 $return .= $param;
 679             } else {
 680                 $param = $this->mysqli->real_escape_string($param);
 681                 $return .= "'$param'";
 682             }
 683             $return .= strtok('?');
 684         }
 685         return $return;
 686     }
 687
 688     /**
 689      * Execute general sql query. Should be used only when no other method suitable.
 690      * Do NOT use this to make changes in db structure, use database_manager::execute_sql() instead!
 691      * @param string $sql query
 692      * @param array $params query parameters
 693      * @return bool true
 694      * @throws dml_exception if error
 695      */
 696     public function execute($sql, array $params=null) {
 697         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
 698
 699         if (strpos($sql, ';') !== false) {
 700             throw new coding_exception('moodle_database::execute() Multiple sql statements found or bound parameters not used properly in query!');
 701         }
 702
 703         $rawsql = $this->emulate_bound_params($sql, $params);
 704
 705         $this->query_start($sql, $params, SQL_QUERY_UPDATE);
 706         $result = $this->mysqli->query($rawsql);
 707         $this->query_end($result);
 708
 709         if ($result === true) {
 710             return true;
 711
 712         } else {
 713             $result->close();
 714             return true;
 715         }
 716     }
 717
 718     /**
 719      * Get a number of records as a moodle_recordset using a SQL statement.
 720      *
 721      * Since this method is a little less readable, use of it should be restricted to
 722      * code where it's possible there might be large datasets being returned.  For known
 723      * small datasets use get_records_sql - it leads to simpler code.
 724      *
 725      * The return type is as for @see function get_recordset.
 726      *
 727      * @param string $sql the SQL select query to execute.
 728      * @param array $params array of sql parameters
 729      * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set).
 730      * @param int $limitnum return a subset comprising this many records (optional, required if $limitfrom is set).
 731      * @return moodle_recordset instance
 732      * @throws dml_exception if error
 733      */
 734     public function get_recordset_sql($sql, array $params=null, $limitfrom=0, $limitnum=0) {
 735         $limitfrom = (int)$limitfrom;
 736         $limitnum  = (int)$limitnum;
 737         $limitfrom = ($limitfrom < 0) ? 0 : $limitfrom;
 738         $limitnum  = ($limitnum < 0)  ? 0 : $limitnum;
 739
 740         if ($limitfrom or $limitnum) {
 741             if ($limitnum < 1) {
 742                 $limitnum = "18446744073709551615";
 743             }
 744             $sql .= " LIMIT $limitfrom, $limitnum";
 745         }
 746
 747         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
 748         $rawsql = $this->emulate_bound_params($sql, $params);
 749
 750         $this->query_start($sql, $params, SQL_QUERY_SELECT);
 751         // no MYSQLI_USE_RESULT here, it would block write ops on affected tables
 752         $result = $this->mysqli->query($rawsql, MYSQLI_STORE_RESULT);
 753         $this->query_end($result);
 754
 755         return $this->create_recordset($result);
 756     }
 757
 758     protected function create_recordset($result) {
 759         return new mysqli_native_moodle_recordset($result);
 760     }
 761
 762     /**
 763      * Get a number of records as an array of objects using a SQL statement.
 764      *
 765      * Return value as for @see function get_records.
 766      *
 767      * @param string $sql the SQL select query to execute. The first column of this SELECT statement
 768      *   must be a unique value (usually the 'id' field), as it will be used as the key of the
 769      *   returned array.
 770      * @param array $params array of sql parameters
 771      * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set).
 772      * @param int $limitnum return a subset comprising this many records (optional, required if $limitfrom is set).
 773      * @return array of objects, or empty array if no records were found
 774      * @throws dml_exception if error
 775      */
 776     public function get_records_sql($sql, array $params=null, $limitfrom=0, $limitnum=0) {
 777         $limitfrom = (int)$limitfrom;
 778         $limitnum  = (int)$limitnum;
 779         $limitfrom = ($limitfrom < 0) ? 0 : $limitfrom;
 780         $limitnum  = ($limitnum < 0)  ? 0 : $limitnum;
 781
 782         if ($limitfrom or $limitnum) {
 783             if ($limitnum < 1) {
 784                 $limitnum = "18446744073709551615";
 785             }
 786             $sql .= " LIMIT $limitfrom, $limitnum";
 787         }
 788
 789         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
 790         $rawsql = $this->emulate_bound_params($sql, $params);
 791
 792         $this->query_start($sql, $params, SQL_QUERY_SELECT);
 793         $result = $this->mysqli->query($rawsql, MYSQLI_STORE_RESULT);
 794         $this->query_end($result);
 795
 796         $return = array();
 797
 798         while($row = $result->fetch_assoc()) {
 799             $row = array_change_key_case($row, CASE_LOWER);
 800             $id  = reset($row);
 801             if (isset($return[$id])) {
 802                 $colname = key($row);
 803                 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);
 804             }
 805             $return[$id] = (object)$row;
 806         }
 807         $result->close();
 808
 809         return $return;
 810     }
 811
 812     /**
 813      * Selects records and return values (first field) as an array using a SQL statement.
 814      *
 815      * @param string $sql The SQL query
 816      * @param array $params array of sql parameters
 817      * @return array of values
 818      * @throws dml_exception if error
 819      */
 820     public function get_fieldset_sql($sql, array $params=null) {
 821         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
 822         $rawsql = $this->emulate_bound_params($sql, $params);
 823
 824         $this->query_start($sql, $params, SQL_QUERY_SELECT);
 825         $result = $this->mysqli->query($rawsql, MYSQLI_STORE_RESULT);
 826         $this->query_end($result);
 827
 828         $return = array();
 829
 830         while($row = $result->fetch_assoc()) {
 831             $return[] = reset($row);
 832         }
 833         $result->close();
 834
 835         return $return;
 836     }
 837
 838     /**
 839      * Insert new record into database, as fast as possible, no safety checks, lobs not supported.
 840      * @param string $table name
 841      * @param mixed $params data record as object or array
 842      * @param bool $returnit return it of inserted record
 843      * @param bool $bulk true means repeated inserts expected
 844      * @param bool $customsequence true if 'id' included in $params, disables $returnid
 845      * @return bool|int true or new id
 846      * @throws dml_exception if error
 847      */
 848     public function insert_record_raw($table, $params, $returnid=true, $bulk=false, $customsequence=false) {
 849         if (!is_array($params)) {
 850             $params = (array)$params;
 851         }
 852
 853         if ($customsequence) {
 854             if (!isset($params['id'])) {
 855                 throw new coding_exception('moodle_database::insert_record_raw() id field must be specified if custom sequences used.');
 856             }
 857             $returnid = false;
 858         } else {
 859             unset($params['id']);
 860         }
 861
 862         if (empty($params)) {
 863             throw new coding_exception('moodle_database::insert_record_raw() no fields found.');
 864         }
 865
 866         $fields = implode(',', array_keys($params));
 867         $qms    = array_fill(0, count($params), '?');
 868         $qms    = implode(',', $qms);
 869
 870         $sql = "INSERT INTO {$this->prefix}$table ($fields) VALUES($qms)";
 871
 872         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
 873         $rawsql = $this->emulate_bound_params($sql, $params);
 874
 875         $this->query_start($sql, $params, SQL_QUERY_INSERT);
 876         $result = $this->mysqli->query($rawsql);
 877         $id = @$this->mysqli->insert_id; // must be called before query_end() which may insert log into db
 878         $this->query_end($result);
 879
 880         if (!$id) {
 881             throw new dml_write_exception('unknown error fetching inserted id');
 882         }
 883
 884         if (!$returnid) {
 885             return true;
 886         } else {
 887             return (int)$id;
 888         }
 889     }
 890
 891     /**
 892      * Insert a record into a table and return the "id" field if required.
 893      *
 894      * Some conversions and safety checks are carried out. Lobs are supported.
 895      * If the return ID isn't required, then this just reports success as true/false.
 896      * $data is an object containing needed data
 897      * @param string $table The database table to be inserted into
 898      * @param object $data A data object with values for one or more fields in the record
 899      * @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.
 900      * @return bool|int true or new id
 901      * @throws dml_exception if error
 902      */
 903     public function insert_record($table, $dataobject, $returnid=true, $bulk=false) {
 904         $dataobject = (array)$dataobject;
 905
 906         $columns = $this->get_columns($table);
 907         $cleaned = array();
 908
 909         foreach ($dataobject as $field=>$value) {
 910             if ($field === 'id') {
 911                 continue;
 912             }
 913             if (!isset($columns[$field])) {
 914                 continue;
 915             }
 916             $column = $columns[$field];
 917             $cleaned[$field] = $this->normalise_value($column, $value);
 918         }
 919
 920         return $this->insert_record_raw($table, $cleaned, $returnid, $bulk);
 921     }
 922
 923     /**
 924      * Import a record into a table, id field is required.
 925      * Safety checks are NOT carried out. Lobs are supported.
 926      *
 927      * @param string $table name of database table to be inserted into
 928      * @param object $dataobject A data object with values for one or more fields in the record
 929      * @return bool true
 930      * @throws dml_exception if error
 931      */
 932     public function import_record($table, $dataobject) {
 933         $dataobject = (array)$dataobject;
 934
 935         $columns = $this->get_columns($table);
 936         $cleaned = array();
 937
 938         foreach ($dataobject as $field=>$value) {
 939             if (!isset($columns[$field])) {
 940                 continue;
 941             }
 942             $cleaned[$field] = $value;
 943         }
 944
 945         return $this->insert_record_raw($table, $cleaned, false, true, true);
 946     }
 947
 948     /**
 949      * Update record in database, as fast as possible, no safety checks, lobs not supported.
 950      * @param string $table name
 951      * @param mixed $params data record as object or array
 952      * @param bool true means repeated updates expected
 953      * @return bool true
 954      * @throws dml_exception if error
 955      */
 956     public function update_record_raw($table, $params, $bulk=false) {
 957         $params = (array)$params;
 958
 959         if (!isset($params['id'])) {
 960             throw new coding_exception('moodle_database::update_record_raw() id field must be specified.');
 961         }
 962         $id = $params['id'];
 963         unset($params['id']);
 964
 965         if (empty($params)) {
 966             throw new coding_exception('moodle_database::update_record_raw() no fields found.');
 967         }
 968
 969         $sets = array();
 970         foreach ($params as $field=>$value) {
 971             $sets[] = "$field = ?";
 972         }
 973
 974         $params[] = $id; // last ? in WHERE condition
 975
 976         $sets = implode(',', $sets);
 977         $sql = "UPDATE {$this->prefix}$table SET $sets WHERE id=?";
 978
 979         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
 980         $rawsql = $this->emulate_bound_params($sql, $params);
 981
 982         $this->query_start($sql, $params, SQL_QUERY_UPDATE);
 983         $result = $this->mysqli->query($rawsql);
 984         $this->query_end($result);
 985
 986         return true;
 987     }
 988
 989     /**
 990      * Update a record in a table
 991      *
 992      * $dataobject is an object containing needed data
 993      * Relies on $dataobject having a variable "id" to
 994      * specify the record to update
 995      *
 996      * @param string $table The database table to be checked against.
 997      * @param object $dataobject An object with contents equal to fieldname=>fieldvalue. Must have an entry for 'id' to map to the table specified.
 998      * @param bool true means repeated updates expected
 999      * @return bool true
1000      * @throws dml_exception if error
1001      */
1002     public function update_record($table, $dataobject, $bulk=false) {
1003         $dataobject = (array)$dataobject;
1004
1005         $columns = $this->get_columns($table);
1006         $cleaned = array();
1007
1008         foreach ($dataobject as $field=>$value) {
1009             if (!isset($columns[$field])) {
1010                 continue;
1011             }
1012             $column = $columns[$field];
1013             $cleaned[$field] = $this->normalise_value($column, $value);
1014         }
1015
1016         return $this->update_record_raw($table, $cleaned, $bulk);
1017     }
1018
1019     /**
1020      * Set a single field in every table record which match a particular WHERE clause.
1021      *
1022      * @param string $table The database table to be checked against.
1023      * @param string $newfield the field to set.
1024      * @param string $newvalue the value to set the field to.
1025      * @param string $select A fragment of SQL to be used in a where clause in the SQL call.
1026      * @param array $params array of sql parameters
1027      * @return bool true
1028      * @throws dml_exception if error
1029      */
1030     public function set_field_select($table, $newfield, $newvalue, $select, array $params=null) {
1031         if ($select) {
1032             $select = "WHERE $select";
1033         }
1034         if (is_null($params)) {
1035             $params = array();
1036         }
1037         list($select, $params, $type) = $this->fix_sql_params($select, $params);
1038
1039         // Get column metadata
1040         $columns = $this->get_columns($table);
1041         $column = $columns[$newfield];
1042
1043         $normalised_value = $this->normalise_value($column, $newvalue);
1044
1045         if (is_null($normalised_value)) {
1046             $newfield = "$newfield = NULL";
1047         } else {
1048             $newfield = "$newfield = ?";
1049             array_unshift($params, $normalised_value);
1050         }
1051         $sql = "UPDATE {$this->prefix}$table SET $newfield $select";
1052         $rawsql = $this->emulate_bound_params($sql, $params);
1053
1054         $this->query_start($sql, $params, SQL_QUERY_UPDATE);
1055         $result = $this->mysqli->query($rawsql);
1056         $this->query_end($result);
1057
1058         return true;
1059     }
1060
1061     /**
1062      * Delete one or more records from a table which match a particular WHERE clause.
1063      *
1064      * @param string $table The database table to be checked against.
1065      * @param string $select A fragment of SQL to be used in a where clause in the SQL call (used to define the selection criteria).
1066      * @param array $params array of sql parameters
1067      * @return bool true
1068      * @throws dml_exception if error
1069      */
1070     public function delete_records_select($table, $select, array $params=null) {
1071         if ($select) {
1072             $select = "WHERE $select";
1073         }
1074         $sql = "DELETE FROM {$this->prefix}$table $select";
1075
1076         list($sql, $params, $type) = $this->fix_sql_params($sql, $params);
1077         $rawsql = $this->emulate_bound_params($sql, $params);
1078
1079         $this->query_start($sql, $params, SQL_QUERY_UPDATE);
1080         $result = $this->mysqli->query($rawsql);
1081         $this->query_end($result);
1082
1083         return true;
1084     }
1085
1086     public function sql_cast_char2int($fieldname, $text=false) {
1087         return ' CAST(' . $fieldname . ' AS SIGNED) ';
1088     }
1089
1090     public function sql_cast_char2real($fieldname, $text=false) {
1091         return ' CAST(' . $fieldname . ' AS DECIMAL) ';
1092     }
1093
1094     /**
1095      * Returns 'LIKE' part of a query.
1096      *
1097      * @param string $fieldname usually name of the table column
1098      * @param string $param usually bound query parameter (?, :named)
1099      * @param bool $casesensitive use case sensitive search
1100      * @param bool $accensensitive use accent sensitive search (not all databases support accent insensitive)
1101      * @param bool $notlike true means "NOT LIKE"
1102      * @param string $escapechar escape char for '%' and '_'
1103      * @return string SQL code fragment
1104      */
1105     public function sql_like($fieldname, $param, $casesensitive = true, $accentsensitive = true, $notlike = false, $escapechar = '\\') {
1106         if (strpos($param, '%') !== false) {
1107             debugging('Potential SQL injection detected, sql_ilike() expects bound parameters (? or :named)');
1108         }
1109         $escapechar = $this->mysqli->real_escape_string($escapechar); // prevents problems with C-style escapes of enclosing '\'
1110
1111         $LIKE = $notlike ? 'NOT LIKE' : 'LIKE';
1112         if ($casesensitive) {
1113             return "$fieldname $LIKE $param COLLATE utf8_bin ESCAPE '$escapechar'";
1114         } else {
1115             if ($accentsensitive) {
1116                 return "LOWER($fieldname) $LIKE LOWER($param) COLLATE utf8_bin ESCAPE '$escapechar'";
1117             } else {
1118                 return "$fieldname $LIKE $param ESCAPE '$escapechar'";
1119             }
1120         }
1121     }
1122
1123     /**
1124      * Returns the proper SQL to do CONCAT between the elements passed
1125      * Can take many parameters
1126      *
1127      * @param string $str,... 1 or more fields/strings to concat
1128      *
1129      * @return string The concat sql
1130      */
1131     public function sql_concat() {
1132         $arr = func_get_args();
1133         $s = implode(', ', $arr);
1134         if ($s === '') {
1135             return "''";
1136         }
1137         return "CONCAT($s)";
1138     }
1139
1140     /**
1141      * Returns the proper SQL to do CONCAT between the elements passed
1142      * with a given separator
1143      *
1144      * @param string $separator The string to use as the separator
1145      * @param array $elements An array of items to concatenate
1146      * @return string The concat SQL
1147      */
1148     public function sql_concat_join($separator="' '", $elements=array()) {
1149         $s = implode(', ', $elements);
1150
1151         if ($s === '') {
1152             return "''";
1153         }
1154         return "CONCAT_WS($separator, $s)";
1155     }
1156
1157     /**
1158      * Returns the SQL text to be used to calculate the length in characters of one expression.
1159      * @param string fieldname or expression to calculate its length in characters.
1160      * @return string the piece of SQL code to be used in the statement.
1161      */
1162     public function sql_length($fieldname) {
1163         return ' CHAR_LENGTH(' . $fieldname . ')';
1164     }
1165
1166     /**
1167      * Does this driver support regex syntax when searching
1168      */
1169     public function sql_regex_supported() {
1170         return true;
1171     }
1172
1173     /**
1174      * Return regex positive or negative match sql
1175      * @param bool $positivematch
1176      * @return string or empty if not supported
1177      */
1178     public function sql_regex($positivematch=true) {
1179         return $positivematch ? 'REGEXP' : 'NOT REGEXP';
1180     }
1181
1182     public function sql_cast_2signed($fieldname) {
1183         return ' CAST(' . $fieldname . ' AS SIGNED) ';
1184     }
1185
1186 /// session locking
1187     public function session_lock_supported() {
1188         return true;
1189     }
1190
1191     public function get_session_lock($rowid) {
1192         parent::get_session_lock($rowid);
1193         $fullname = $this->dbname.'-'.$this->prefix.'-session-'.$rowid;
1194         $sql = "SELECT GET_LOCK('$fullname',120)";
1195         $this->query_start($sql, null, SQL_QUERY_AUX);
1196         $result = $this->mysqli->query($sql);
1197         $this->query_end($result);
1198
1199         if ($result) {
1200             $arr = $result->fetch_assoc();
1201             $result->close();
1202
1203             if (reset($arr) == 1) {
1204                 return;
1205             } else {
1206                 // try again!
1207                 $this->get_session_lock($rowid);
1208             }
1209         }
1210     }
1211
1212     public function release_session_lock($rowid) {
1213         parent::release_session_lock($rowid);
1214         $fullname = $this->dbname.'-'.$this->prefix.'-session-'.$rowid;
1215         $sql = "SELECT RELEASE_LOCK('$fullname')";
1216         $this->query_start($sql, null, SQL_QUERY_AUX);
1217         $result = $this->mysqli->query($sql);
1218         $this->query_end($result);
1219
1220         if ($result) {
1221             $result->close();
1222         }
1223     }
1224
1225 /// transactions
1226     /**
1227      * Are transactions supported?
1228      * It is not responsible to run productions servers
1229      * on databases without transaction support ;-)
1230      *
1231      * MyISAM does not support support transactions.
1232      *
1233      * You can override this via the dbtransactions option.
1234      *
1235      * @return bool
1236      */
1237     protected function transactions_supported() {
1238         if (!is_null($this->transactions_supported)) {
1239             return $this->transactions_supported;
1240         }
1241
1242         // this is all just guessing, might be better to just specify it in config.php
1243         if (isset($this->dboptions['dbtransactions'])) {
1244             $this->transactions_supported = $this->dboptions['dbtransactions'];
1245             return $this->transactions_supported;
1246         }
1247
1248         $this->transactions_supported = false;
1249
1250         $engine = $this->get_dbengine();
1251
1252         // Only will accept transactions if using compatible storage engine (more engines can be added easily BDB, Falcon...)
1253         if (in_array($engine, array('InnoDB', 'INNOBASE', 'BDB', 'XtraDB', 'Aria', 'Falcon'))) {
1254             $this->transactions_supported = true;
1255         }
1256
1257         return $this->transactions_supported;
1258     }
1259
1260     /**
1261      * Driver specific start of real database transaction,
1262      * this can not be used directly in code.
1263      * @return void
1264      */
1265     protected function begin_transaction() {
1266         if (!$this->transactions_supported()) {
1267             return;
1268         }
1269
1270         $sql = "SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED";
1271         $this->query_start($sql, NULL, SQL_QUERY_AUX);
1272         $result = $this->mysqli->query($sql);
1273         $this->query_end($result);
1274
1275         $sql = "START TRANSACTION";
1276         $this->query_start($sql, NULL, SQL_QUERY_AUX);
1277         $result = $this->mysqli->query($sql);
1278         $this->query_end($result);
1279     }
1280
1281     /**
1282      * Driver specific commit of real database transaction,
1283      * this can not be used directly in code.
1284      * @return void
1285      */
1286     protected function commit_transaction() {
1287         if (!$this->transactions_supported()) {
1288             return;
1289         }
1290
1291         $sql = "COMMIT";
1292         $this->query_start($sql, NULL, SQL_QUERY_AUX);
1293         $result = $this->mysqli->query($sql);
1294         $this->query_end($result);
1295     }
1296
1297     /**
1298      * Driver specific abort of real database transaction,
1299      * this can not be used directly in code.
1300      * @return void
1301      */
1302     protected function rollback_transaction() {
1303         if (!$this->transactions_supported()) {
1304             return;
1305         }
1306
1307         $sql = "ROLLBACK";
1308         $this->query_start($sql, NULL, SQL_QUERY_AUX);
1309         $result = $this->mysqli->query($sql);
1310         $this->query_end($result);
1311
1312         return true;
1313     }
1314 }