Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**

 * Native mysqli class representing moodle database interface.

 *

 * @package    core_dml

 * @copyright  2008 Petr Skoda (http://skodak.org)

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

defined('MOODLE_INTERNAL') || die();

require_once(__DIR__.'/moodle_database.php');

require_once(__DIR__.'/moodle_read_replica_trait.php');

require_once(__DIR__.'/mysqli_native_moodle_recordset.php');

require_once(__DIR__.'/mysqli_native_moodle_temptables.php');

/**

 * Native mysqli class representing moodle database interface.

 *

 * @package    core_dml

 * @copyright  2008 Petr Skoda (http://skodak.org)

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class mysqli_native_moodle_database extends moodle_database {

    use moodle_read_replica_trait {

        can_use_readonly as read_replica_can_use_readonly;

    }

    /** @var array $sslmodes */

    private static $sslmodes = [

        'require',

        'verify-full'

    ];

    /** @var mysqli $mysqli */

    protected $mysqli = null;

    /** @var bool is compressed row format supported cache */

    protected $compressedrowformatsupported = null;

    /** @var string DB server actual version */

    protected $serverversion = null;

    private $transactions_supported = null;

    /**

     * Attempt to create the database

     * @param string $dbhost

     * @param string $dbuser

     * @param string $dbpass

     * @param string $dbname

     * @return bool success

     * @throws dml_exception A DML specific exception is thrown for any errors.

     */

    public function create_database($dbhost, $dbuser, $dbpass, $dbname, ?array $dboptions=null) {

        $driverstatus = $this->driver_installed();

        if ($driverstatus !== true) {

            throw new dml_exception('dbdriverproblem', $driverstatus);

        }

        if (!empty($dboptions['dbsocket'])

                and (strpos($dboptions['dbsocket'], '/') !== false or strpos($dboptions['dbsocket'], '\\') !== false)) {

            $dbsocket = $dboptions['dbsocket'];

        } else {

            $dbsocket = ini_get('mysqli.default_socket');

        }

        if (empty($dboptions['dbport'])) {

            $dbport = (int)ini_get('mysqli.default_port');

        } else {

            $dbport = (int)$dboptions['dbport'];

        }

        // verify ini.get does not return nonsense

        if (empty($dbport)) {

            $dbport = 3306;

        }

        ob_start();

        $conn = new mysqli($dbhost, $dbuser, $dbpass, '', $dbport, $dbsocket); // Connect without db

        $dberr = ob_get_contents();

        ob_end_clean();

        $errorno = @$conn->connect_errno;

        if ($errorno !== 0) {

            throw new dml_connection_exception($dberr);

        }

        // Normally a check would be done before setting utf8mb4, but the database can be created

        // before the enviroment checks are done. We'll proceed with creating the database and then do checks next.

        $charset = 'utf8mb4';

        if (isset($dboptions['dbcollation']) and (strpos($dboptions['dbcollation'], 'utf8_') === 0

                || strpos($dboptions['dbcollation'], 'utf8mb4_') === 0)) {

            $collation = $dboptions['dbcollation'];

            $collationinfo = explode('_', $dboptions['dbcollation']);

            $charset = reset($collationinfo);

        } else {

            $collation = 'utf8mb4_unicode_ci';

        }

        $result = $conn->query("CREATE DATABASE $dbname DEFAULT CHARACTER SET $charset DEFAULT COLLATE ".$collation);

        $conn->close();

        if (!$result) {

            throw new dml_exception('cannotcreatedb');

        }

        return true;

    }

    /**

     * Detects if all needed PHP stuff installed.

     * Note: can be used before connect()

     * @return mixed true if ok, string if something

     */

    public function driver_installed() {

        if (!extension_loaded('mysqli')) {

            return get_string('mysqliextensionisnotpresentinphp', 'install');

        }

        return true;

    }

    /**

     * Returns database family type - describes SQL dialect

     * Note: can be used before connect()

     * @return string db family name (mysql, postgres, mssql, etc.)

     */

    public function get_dbfamily() {

        return 'mysql';

    }

    /**

     * Returns more specific database driver type

     * Note: can be used before connect()

     * @return string db type mysqli, pgsql, mssql, sqlsrv

     */

    protected function get_dbtype() {

        return 'mysqli';

    }

    /**

     * Returns general database library name

     * Note: can be used before connect()

     * @return string db type pdo, native

     */

    protected function get_dblibrary() {

        return 'native';

    }

    /**

     * Returns the current MySQL db engine.

     *

     * This is an ugly workaround for MySQL default engine problems,

     * Moodle is designed to work best on ACID compliant databases

     * with full transaction support. Do not use MyISAM.

     *

     * @return string or null MySQL engine name

     */

    public function get_dbengine() {

        if (isset($this->dboptions['dbengine'])) {

            return $this->dboptions['dbengine'];

        }

        if ($this->external) {

            return null;

        }

        $engine = null;

        // Look for current engine of our config table (the first table that gets created),

        // so that we create all tables with the same engine.

        $sql = "SELECT engine

                  FROM INFORMATION_SCHEMA.TABLES

                 WHERE table_schema = DATABASE() AND table_name = '{$this->prefix}config'";

        $this->query_start($sql, null, SQL_QUERY_AUX);

        $result = $this->mysqli->query($sql);

        $this->query_end($result);

        if ($rec = $result->fetch_assoc()) {

            // MySQL 8 BC: information_schema.* returns the fields in upper case.

            $rec = array_change_key_case($rec, CASE_LOWER);

            $engine = $rec['engine'];

        }

        $result->close();

        if ($engine) {

            // Cache the result to improve performance.

            $this->dboptions['dbengine'] = $engine;

            return $engine;

        }

        // Get the default database engine.

        $sql = "SELECT @@default_storage_engine engine";

        $this->query_start($sql, null, SQL_QUERY_AUX);

        $result = $this->mysqli->query($sql);

        $this->query_end($result);

        if ($rec = $result->fetch_assoc()) {

            $engine = $rec['engine'];

        }

        $result->close();

        if ($engine === 'MyISAM') {

            // we really do not want MyISAM for Moodle, InnoDB or XtraDB is a reasonable defaults if supported

            $sql = "SHOW STORAGE ENGINES";

            $this->query_start($sql, null, SQL_QUERY_AUX);

            $result = $this->mysqli->query($sql);

            $this->query_end($result);

            $engines = array();

            while ($res = $result->fetch_assoc()) {

                if ($res['Support'] === 'YES' or $res['Support'] === 'DEFAULT') {

                    $engines[$res['Engine']] = true;

                }

            }

            $result->close();

            if (isset($engines['InnoDB'])) {

                $engine = 'InnoDB';

            }

            if (isset($engines['XtraDB'])) {

                $engine = 'XtraDB';

            }

        }

        // Cache the result to improve performance.

        $this->dboptions['dbengine'] = $engine;

        return $engine;

    }

    /**

     * Returns the current MySQL db collation.

     *

     * This is an ugly workaround for MySQL default collation problems.

     *

     * @return string or null MySQL collation name

     */

    public function get_dbcollation() {

        if (isset($this->dboptions['dbcollation'])) {

            return $this->dboptions['dbcollation'];

        }

    }

    /**

     * Set 'dbcollation' option

     *

     * @return string|null $dbcollation

     */

    private function detect_collation(): ?string {

        if ($this->external) {

            return null;

        }

        $collation = null;

        // Look for current collation of our config table (the first table that gets created),

        // so that we create all tables with the same collation.

        $sql = "SELECT collation_name

                  FROM INFORMATION_SCHEMA.COLUMNS

                 WHERE table_schema = DATABASE() AND table_name = '{$this->prefix}config' AND column_name = 'value'";

        $result = $this->mysqli->query($sql);

        if ($rec = $result->fetch_assoc()) {

            // MySQL 8 BC: information_schema.* returns the fields in upper case.

            $rec = array_change_key_case($rec, CASE_LOWER);

            $collation = $rec['collation_name'];

        }

        $result->close();

        if (!$collation) {

            // Get the default database collation, but only if using UTF-8.

            $sql = "SELECT @@collation_database";

            $result = $this->mysqli->query($sql);

            if ($rec = $result->fetch_assoc()) {

                if (strpos($rec['@@collation_database'], 'utf8_') === 0 || strpos($rec['@@collation_database'], 'utf8mb4_') === 0) {

                    $collation = $rec['@@collation_database'];

                }

            }

            $result->close();

        }

        if (!$collation) {

            // We want only utf8 compatible collations.

            $collation = null;

            $sql = "SHOW COLLATION WHERE Collation LIKE 'utf8mb4\_%' AND Charset = 'utf8mb4'";

            $result = $this->mysqli->query($sql);

            while ($res = $result->fetch_assoc()) {

                $collation = $res['Collation'];

                if (strtoupper($res['Default']) === 'YES') {

                    $collation = $res['Collation'];

                    break;

                }

            }

            $result->close();

        }

        // Cache the result to improve performance.

        $this->dboptions['dbcollation'] = $collation;

        return $collation;

    }

    /**

     * Tests if the Antelope file format is still supported or it has been removed.

     * When removed, only Barracuda file format is supported, given the XtraDB/InnoDB engine.

     *

     * @return bool True if the Antelope file format has been removed; otherwise, false.

     */

    protected function is_antelope_file_format_no_more_supported() {

        // Breaking change: Antelope file format support has been removed from both MySQL and MariaDB.

        // The following InnoDB file format configuration parameters were deprecated and then removed:

        // - innodb_file_format

        // - innodb_file_format_check

        // - innodb_file_format_max

        // - innodb_large_prefix

        // 1. MySQL: deprecated in 5.7.7 and removed 8.0.0+.

        $ismysqlge8d0d0 = ($this->get_dbtype() == 'mysqli' || $this->get_dbtype() == 'auroramysql') &&

                version_compare($this->get_server_info()['version'], '8.0.0', '>=');

        // 2. MariaDB: deprecated in 10.2.0 and removed 10.3.1+.

        $ismariadbge10d3d1 = ($this->get_dbtype() == 'mariadb') &&

                version_compare($this->get_server_info()['version'], '10.3.1', '>=');

        return $ismysqlge8d0d0 || $ismariadbge10d3d1;

    }

    /**

     * Get the row format from the database schema.

     *

     * @param string $table

     * @return string row_format name or null if not known or table does not exist.

     */

    public function get_row_format($table = null) {

        $rowformat = null;

        if (isset($table)) {

            $table = $this->mysqli->real_escape_string($table);

            $sql = "SELECT row_format

                      FROM INFORMATION_SCHEMA.TABLES

                     WHERE table_schema = DATABASE() AND table_name = '{$this->prefix}$table'";

        } else {

            if ($this->is_antelope_file_format_no_more_supported()) {

                // Breaking change: Antelope file format support has been removed, only Barracuda.

                $dbengine = $this->get_dbengine();

                $supporteddbengines = array('InnoDB', 'XtraDB');

                if (in_array($dbengine, $supporteddbengines)) {

                    $rowformat = 'Barracuda';

                }

                return $rowformat;

            }

            $sql = "SHOW VARIABLES LIKE 'innodb_file_format'";

        }

        $this->query_start($sql, null, SQL_QUERY_AUX);

        $result = $this->mysqli->query($sql);

        $this->query_end($result);

        if ($rec = $result->fetch_assoc()) {

            // MySQL 8 BC: information_schema.* returns the fields in upper case.

            $rec = array_change_key_case($rec, CASE_LOWER);

            if (isset($table)) {

                $rowformat = $rec['row_format'];

            } else {

                $rowformat = $rec['value'];

            }

        }

        $result->close();

        return $rowformat;

    }

    /**

     * Is this database compatible with compressed row format?

     * This feature is necessary for support of large number of text

     * columns in InnoDB/XtraDB database.

     *

     * @param bool $cached use cached result

     * @return bool true if table can be created or changed to compressed row format.

     */

    public function is_compressed_row_format_supported($cached = true) {

        if ($cached and isset($this->compressedrowformatsupported)) {

            return($this->compressedrowformatsupported);

        }

        $engine = strtolower($this->get_dbengine());

        $info = $this->get_server_info();

        if (version_compare($info['version'], '5.5.0') < 0) {

            // MySQL 5.1 is not supported here because we cannot read the file format.

            $this->compressedrowformatsupported = false;

        } else if ($engine !== 'innodb' and $engine !== 'xtradb') {

            // Other engines are not supported, most probably not compatible.

            $this->compressedrowformatsupported = false;

        } else if (!$this->is_file_per_table_enabled()) {

            $this->compressedrowformatsupported = false;

        } else if ($this->get_row_format() !== 'Barracuda') {

            $this->compressedrowformatsupported = false;

        } else if ($this->get_dbtype() === 'auroramysql') {

            // Aurora MySQL doesn't support COMPRESSED and falls back to COMPACT if you try to use it.

            $this->compressedrowformatsupported = false;

        } else {

            // All the tests passed, we can safely use ROW_FORMAT=Compressed in sql statements.

            $this->compressedrowformatsupported = true;

        }

        return $this->compressedrowformatsupported;

    }

    /**

     * Check the database to see if innodb_file_per_table is on.

     *

     * @return bool True if on otherwise false.

     */

    public function is_file_per_table_enabled() {

        if ($filepertable = $this->get_record_sql("SHOW VARIABLES LIKE 'innodb_file_per_table'")) {

            if ($filepertable->value == 'ON') {

                return true;

            }

        }

        return false;

    }

    /**

     * Check the database to see if innodb_large_prefix is on.

     *

     * @return bool True if on otherwise false.

     */

    public function is_large_prefix_enabled() {

        if ($this->is_antelope_file_format_no_more_supported()) {

            // Breaking change: Antelope file format support has been removed, only Barracuda.

            return true;

        }

        if ($largeprefix = $this->get_record_sql("SHOW VARIABLES LIKE 'innodb_large_prefix'")) {

            if ($largeprefix->value == 'ON') {

                return true;

            }

        }

        return false;

    }

    /**

     * Determine if the row format should be set to compressed, dynamic, or default.

     *

     * Terrible kludge. If we're using utf8mb4 AND we're using InnoDB, we need to specify row format to

     * be either dynamic or compressed (default is compact) in order to allow for bigger indexes (MySQL

     * errors #1709 and #1071).

     *

     * @param  string $engine The database engine being used. Will be looked up if not supplied.

     * @param  string $collation The database collation to use. Will look up the current collation if not supplied.

     * @return string An sql fragment to add to sql statements.

     */

    public function get_row_format_sql($engine = null, $collation = null) {

        if (!isset($engine)) {

            $engine = $this->get_dbengine();

        }

        $engine = strtolower($engine);

        if (!isset($collation)) {

            $collation = $this->get_dbcollation();

        }

        $rowformat = '';

        if (($engine === 'innodb' || $engine === 'xtradb') && strpos($collation, 'utf8mb4_') === 0) {

            if ($this->is_compressed_row_format_supported()) {

                $rowformat = "ROW_FORMAT=Compressed";

            } else {

                $rowformat = "ROW_FORMAT=Dynamic";

            }

        }

        return $rowformat;

    }

    /**

     * Returns localised database type name

     * Note: can be used before connect()

     * @return string

     */

    public function get_name() {

        return get_string('nativemysqli', 'install');

    }

    /**

     * Returns localised database configuration help.

     * Note: can be used before connect()

     * @return string

     */

    public function get_configuration_help() {

        return get_string('nativemysqlihelp', 'install');

    }

    /**

     * Connect to db

     * @param string $dbhost The database host.

     * @param string $dbuser The database username.

     * @param string $dbpass The database username's password.

     * @param string $dbname The name of the database being connected to.e

     * @param mixed $prefix string means moodle db prefix, false used for external databases where prefix not used

     * @param array $dboptions driver specific options

     * @return bool success

     * @throws moodle_exception

     * @throws dml_connection_exception if error

     */

    public function raw_connect(string $dbhost, string $dbuser, string $dbpass, string $dbname, $prefix, ?array $dboptions=null): bool {

        $driverstatus = $this->driver_installed();

        if ($driverstatus !== true) {

            throw new dml_exception('dbdriverproblem', $driverstatus);

        }

        $this->store_settings($dbhost, $dbuser, $dbpass, $dbname, $prefix, $dboptions);

        // The dbsocket option is used ONLY if host is null or 'localhost'.

        // You can not disable it because it is always tried if dbhost is 'localhost'.

        if (!empty($this->dboptions['dbsocket'])

                and (strpos($this->dboptions['dbsocket'], '/') !== false or strpos($this->dboptions['dbsocket'], '\\') !== false)) {

            $dbsocket = $this->dboptions['dbsocket'];

        } else {

            $dbsocket = ini_get('mysqli.default_socket');

        }

        if (empty($this->dboptions['dbport'])) {

            $dbport = (int)ini_get('mysqli.default_port');

        } else {

            $dbport = (int)$this->dboptions['dbport'];

        }

        // verify ini.get does not return nonsense

        if (empty($dbport)) {

            $dbport = 3306;

        }

        if ($dbhost and !empty($this->dboptions['dbpersist'])) {

            $dbhost = "p:$dbhost";

        }

        // We want to keep exceptions out from the native driver.

        // TODO: See MDL-75761 for future improvements.

        mysqli_report(MYSQLI_REPORT_OFF); // Disable reporting (default before PHP 8.1).

        $this->mysqli = mysqli_init();

        if (!empty($this->dboptions['connecttimeout'])) {

            $this->mysqli->options(MYSQLI_OPT_CONNECT_TIMEOUT, $this->dboptions['connecttimeout']);

        }

        $flags = 0;

        if ($this->dboptions['clientcompress'] ?? false) {

            $flags |= MYSQLI_CLIENT_COMPRESS;

        }

        if (isset($this->dboptions['ssl'])) {

            $sslmode = $this->dboptions['ssl'];

            if (!in_array($sslmode, self::$sslmodes, true)) {

                throw new moodle_exception("Invalid 'dboptions''ssl' value '$sslmode'");

            }

            $flags |= MYSQLI_CLIENT_SSL;

            if ($sslmode === 'verify-full') {

                $flags |= MYSQLI_CLIENT_SSL_VERIFY_SERVER_CERT;

            }

        }

        $conn = null;

        $dberr = null;

        try {

            // real_connect() is doing things we don't expext.

            $conn = @$this->mysqli->real_connect($dbhost, $dbuser, $dbpass, $dbname, $dbport, $dbsocket, $flags);

        } catch (\Exception $e) {

            $dberr = "$e";

        }

        if (!$conn) {

            $dberr = $dberr ?: "{$this->mysqli->connect_error} ({$this->mysqli->connect_errno})";

            $this->mysqli = null;

            throw new dml_connection_exception($dberr);

        }

        // Disable logging until we are fully setup.

        $this->query_log_prevent();

        if (isset($dboptions['dbcollation'])) {

            $collation = $this->dboptions['dbcollation'] = $dboptions['dbcollation'];

        } else {

            $collation = $this->detect_collation();

        }

        $collationinfo = explode('_', $collation);

        $charset = reset($collationinfo);

        $this->mysqli->set_charset($charset);

        // If available, enforce strict mode for the session. That guaranties

        // standard behaviour under some situations, avoiding some MySQL nasty

        // habits like truncating data or performing some transparent cast losses.

        // With strict mode enforced, Moodle DB layer will be consistently throwing

        // the corresponding exceptions as expected.

        $si = $this->get_server_info();

        if (version_compare($si['version'], '5.0.2', '>=')) {

            $sql = "SET SESSION sql_mode = 'STRICT_ALL_TABLES'";

            $result = $this->mysqli->query($sql);

        }

        // We can enable logging now.

        $this->query_log_allow();

        // Connection stabilised and configured, going to instantiate the temptables controller

        $this->temptables = new mysqli_native_moodle_temptables($this);

        return true;

    }

    /**

     * Close database connection and release all resources

     * and memory (especially circular memory references).

     * Do NOT use connect() again, create a new instance if needed.

     */

    public function dispose() {

        parent::dispose(); // Call parent dispose to write/close session and other common stuff before closing connection

        if ($this->mysqli) {

            $this->mysqli->close();

            $this->mysqli = null;

        }

    }

    /**

     * Gets db handle currently used with queries

     * @return resource

     */

    protected function get_db_handle() {

        return $this->mysqli;

    }

    /**

     * Sets db handle to be used with subsequent queries

     * @param resource $dbh

     * @return void

     */

    protected function set_db_handle($dbh): void {

        $this->mysqli = $dbh;

    }

    /**

     * Check if The query qualifies for readonly connection execution

     * Logging queries are exempt, those are write operations that circumvent

     * standard query_start/query_end paths.

     * @param int $type type of query

     * @param string $sql

     * @return bool

     */

    protected function can_use_readonly(int $type, string $sql): bool {

        // ... *_LOCK queries always go to primary.

        if (preg_match('/\b(GET|RELEASE)_LOCK/i', $sql)) {

            return false;

        }

        return $this->read_replica_can_use_readonly($type, $sql);

    }

    /**

     * Returns the version of the MySQL server, as reported by the PHP client connection.

     *

     * Wrap $this->mysqli->server_info to improve testing strategy.

     *

     * @return string A string representing the version of the MySQL server that the MySQLi extension is connected to.

     */

    protected function get_mysqli_server_info(): string {

        return $this->mysqli->server_info;

    }

    /**

     * Returns the version of the MySQL server, as reported by 'SELECT VERSION()' query.

     *

     * @return string A string that indicates the MySQL server version.

     * @throws dml_read_exception If the execution of 'SELECT VERSION()' query will fail.

     */

    protected function get_version_from_db(): string {

        $version = null;

        // Query the DB server for the server version.

        $sql = "SELECT VERSION() version;";

        try {

            $result = $this->mysqli->query($sql);

            if ($result) {

                if ($row = $result->fetch_assoc()) {

                    $version = $row['version'];

                }

                $result->close();

                unset($row);

            }

        } catch (\Throwable $e) { // Exceptions in case of MYSQLI_REPORT_STRICT.

            // It looks like we've an issue out of the expected boolean 'false' result above.

            throw new dml_read_exception($e->getMessage(), $sql);

        }

        if (empty($version)) {

            // Exception dml_read_exception usually reports raw mysqli errors i.e. not localised by Moodle.

            throw new dml_read_exception("Unable to read the DB server version.", $sql);

        }

        return $version;

    }

    /**

     * Returns whether $CFG->dboptions['versionfromdb'] has been set to boolean `true`.

     *

     * @return bool True if $CFG->dboptions['versionfromdb'] has been set to boolean `true`. Otherwise, `false`.

     */

    protected function should_db_version_be_read_from_db(): bool {

        if (!empty($this->dboptions['versionfromdb'])) {

            return true;

        }

        return false;

    }

    /**

     * Returns database server info array.

     * @return array Array containing 'description' and 'version' info.

     * @throws dml_read_exception If the execution of 'SELECT VERSION()' query will fail.

     */

    public function get_server_info() {

        $version = $this->serverversion;

        if (empty($version)) {

            $version = $this->get_mysqli_server_info();

            // The version returned by the PHP client could not be the actual DB server version.

            // For example in MariaDB, it was prefixed by the RPL_VERSION_HACK, "5.5.5-" (MDEV-4088), starting from 10.x,

            // when not using an authentication plug-in.

            // Strip the RPL_VERSION_HACK prefix off - it will be "always" there in MariaDB until MDEV-28910 will be implemented.

            $version = str_replace('5.5.5-', '', $version);

            // Should we use the VERSION function to get the actual DB version instead of the PHP client version above?

            if ($this->should_db_version_be_read_from_db()) {

                // Try to query the actual version of the target database server: indeed some cloud providers, e.g. Azure,

                // put a gateway in front of the actual instance which reports its own version to the PHP client

                // and it doesn't represent the actual version of the DB server the PHP client is connected to.

                // Refs:

                // - https://learn.microsoft.com/en-us/azure/mariadb/concepts-supported-versions

                // - https://learn.microsoft.com/en-us/azure/mysql/single-server/concepts-connect-to-a-gateway-node .

                // Reset the version returned by the PHP client with the actual DB version reported by 'VERSION' function.

                $version = $this->get_version_from_db();

            }

            // The version here starts with the following naming scheme: 'X.Y.Z[-<suffix>]'.

            // Example: in MariaDB at least one suffix is "always" there, hardcoded in 'mysql_version.h.in':

            // #define MYSQL_SERVER_VERSION       "@VERSION@-MariaDB"

            // MariaDB and MySQL server version could have extra suffixes too, set by the compilation environment,

            // e.g. '-debug', '-embedded', '-log' or any other vendor specific suffix (e.g. build information).

            // Strip out any suffix.

            $parts = explode('-', $version, 2);

            // Finally, keep just major, minor and patch versions (X.Y.Z) from the reported DB server version.

            $this->serverversion = $parts[0];

        }

        return [

            'description' => $this->get_mysqli_server_info(),

            'version' => $this->serverversion

        ];

    }

    /**

     * Returns supported query parameter types

     * @return int bitmask of accepted SQL_PARAMS_*

     */

    protected function allowed_param_types() {

        return SQL_PARAMS_QM;

    }

    /**

     * Returns last error reported by database engine.

     * @return string error message

     */

    public function get_last_error() {

        return $this->mysqli->error;

    }

    /**

     * Return tables in database WITHOUT current prefix

     * @param bool $usecache if true, returns list of cached tables.

     * @return array of table names in lowercase and without prefix

     */

    public function get_tables($usecache=true) {

        if ($usecache and $this->tables !== null) {

            return $this->tables;

        }

        $this->tables = array();

        $prefix = str_replace('_', '\\_', $this->prefix);

        $sql = "SHOW TABLES LIKE '$prefix%'";

        $this->query_start($sql, null, $usecache ? SQL_QUERY_AUX_READONLY : SQL_QUERY_AUX);

        $result = $this->mysqli->query($sql);

        $this->query_end($result);

        $len = strlen($this->prefix);

        if ($result) {

            while ($arr = $result->fetch_assoc()) {

                $tablename = reset($arr);

                $tablename = substr($tablename, $len);

                $this->tables[$tablename] = $tablename;

            }

            $result->close();

        }

        // Add the currently available temptables

        $this->tables = array_merge($this->tables, $this->temptables->get_temptables());

        return $this->tables;

    }

    /**

     * Return table indexes - everything lowercased.

     * @param string $table The table we want to get indexes from.

     * @return array An associative array of indexes containing 'unique' flag and 'columns' being indexed

     */

    public function get_indexes($table) {

        $indexes = array();

        $fixedtable = $this->fix_table_name($table);

        $sql = "SHOW INDEXES FROM $fixedtable";

        $this->query_start($sql, null, SQL_QUERY_AUX_READONLY);

        $result = $this->mysqli->query($sql);

        try {

            $this->query_end($result);

        } catch (dml_read_exception $e) {

            return $indexes; // table does not exist - no indexes...

        }

        if ($result) {

            while ($res = $result->fetch_object()) {

                if ($res->Key_name === 'PRIMARY') {

                    continue;

                }

                if (!isset($indexes[$res->Key_name])) {

                    $indexes[$res->Key_name] = array('unique'=>empty($res->Non_unique), 'columns'=>array());

                }

                $indexes[$res->Key_name]['columns'][$res->Seq_in_index-1] = $res->Column_name;

            }

            $result->close();

        }

        return $indexes;

    }

    /**

     * Fetches detailed information about columns in table.

     *

     * @param string $table name

     * @return database_column_info[] array of database_column_info objects indexed with column names

     */

    protected function fetch_columns(string $table): array {

        $structure = array();

        $sql = "SELECT column_name, data_type, character_maximum_length, numeric_precision,

                       numeric_scale, is_nullable, column_type, column_default, column_key, extra

                  FROM information_schema.columns

                 WHERE table_name = '" . $this->prefix.$table . "'

                       AND table_schema = '" . $this->dbname . "'

              ORDER BY ordinal_position";

        $this->query_start($sql, null, SQL_QUERY_AUX_READONLY);

        $result = $this->mysqli->query($sql);

        $this->query_end(true); // Don't want to throw anything here ever. MDL-30147

        if ($result === false) {

            return array();

        }

        if ($result->num_rows > 0) {

            // standard table exists

            while ($rawcolumn = $result->fetch_assoc()) {

                // MySQL 8 BC: information_schema.* returns the fields in upper case.

                $rawcolumn = array_change_key_case($rawcolumn, CASE_LOWER);

                $info = (object)$this->get_column_info((object)$rawcolumn);

                $structure[$info->name] = new database_column_info($info);

            }

            $result->close();

        } else {

            // temporary tables are not in information schema, let's try it the old way

            $result->close();

            $fixedtable = $this->fix_table_name($table);

            $sql = "SHOW COLUMNS FROM $fixedtable";

            $this->query_start($sql, null, SQL_QUERY_AUX_READONLY);

            $result = $this->mysqli->query($sql);

            $this->query_end(true);

            if ($result === false) {

                return array();

            }

            while ($rawcolumn = $result->fetch_assoc()) {

                $rawcolumn = (object)array_change_key_case($rawcolumn, CASE_LOWER);

                $rawcolumn->column_name              = $rawcolumn->field; unset($rawcolumn->field);

                $rawcolumn->column_type              = $rawcolumn->type; unset($rawcolumn->type);

                $rawcolumn->character_maximum_length = null;

                $rawcolumn->numeric_precision        = null;

                $rawcolumn->numeric_scale            = null;

                $rawcolumn->is_nullable              = $rawcolumn->null; unset($rawcolumn->null);

                $rawcolumn->column_default           = $rawcolumn->default; unset($rawcolumn->default);

                $rawcolumn->column_key               = $rawcolumn->key; unset($rawcolumn->key);

                if (preg_match('/(enum|varchar)\((\d+)\)/i', $rawcolumn->column_type, $matches)) {

                    $rawcolumn->data_type = $matches[1];

                    $rawcolumn->character_maximum_length = $matches[2];

                } else if (preg_match('/([a-z]*int[a-z]*)\((\d+)\)/i', $rawcolumn->column_type, $matches)) {

                    $rawcolumn->data_type = $matches[1];

                    $rawcolumn->numeric_precision = $matches[2];

                    $rawcolumn->max_length = $rawcolumn->numeric_precision;

                    $type = strtoupper($matches[1]);

                    if ($type === 'BIGINT') {

                        $maxlength = 18;

                    } else if ($type === 'INT' or $type === 'INTEGER') {

                        $maxlength = 9;

                    } else if ($type === 'MEDIUMINT') {

                        $maxlength = 6;

                    } else if ($type === 'SMALLINT') {

                        $maxlength = 4;

                    } else if ($type === 'TINYINT') {

                        $maxlength = 2;

                    } else {

                        // This should not happen.

                        $maxlength = 0;

                    }

                    if ($maxlength < $rawcolumn->max_length) {

                        $rawcolumn->max_length = $maxlength;

                    }

                } else if (preg_match('/(decimal)\((\d+),(\d+)\)/i', $rawcolumn->column_type, $matches)) {

                    $rawcolumn->data_type = $matches[1];

                    $rawcolumn->numeric_precision = $matches[2];

                    $rawcolumn->numeric_scale = $matches[3];

                } else if (preg_match('/(double|float)(\((\d+),(\d+)\))?/i', $rawcolumn->column_type, $matches)) {

                    $rawcolumn->data_type = $matches[1];

                    $rawcolumn->numeric_precision = isset($matches[3]) ? $matches[3] : null;

                    $rawcolumn->numeric_scale = isset($matches[4]) ? $matches[4] : null;

                } else if (preg_match('/([a-z]*text)/i', $rawcolumn->column_type, $matches)) {

                    $rawcolumn->data_type = $matches[1];

                    $rawcolumn->character_maximum_length = -1; // unknown

                } else if (preg_match('/([a-z]*blob)/i', $rawcolumn->column_type, $matches)) {

                    $rawcolumn->data_type = $matches[1];

                } else {

                    $rawcolumn->data_type = $rawcolumn->column_type;

                }

                $info = $this->get_column_info($rawcolumn);

                $structure[$info->name] = new database_column_info($info);

            }

            $result->close();

        }

        return $structure;

    }

    /**

     * Indicates whether column information retrieved from `information_schema.columns` has default values quoted or not.

     * @return boolean True when default values are quoted (breaking change); otherwise, false.

     */

    protected function has_breaking_change_quoted_defaults() {

        return false;

    }

    /**

     * Indicates whether SQL_MODE default value has changed in a not backward compatible way.

     * @return boolean True when SQL_MODE breaks BC; otherwise, false.

     */

    public function has_breaking_change_sqlmode() {

        return false;

    }

    /**

     * Returns moodle column info for raw column from information schema.

     * @param stdClass $rawcolumn

     * @return stdClass standardised colum info

     */

    private function get_column_info(stdClass $rawcolumn) {

        $rawcolumn = (object)$rawcolumn;

        $info = new stdClass();

        $info->name           = $rawcolumn->column_name;

        $info->type           = $rawcolumn->data_type;

        $info->meta_type      = $this->mysqltype2moodletype($rawcolumn->data_type);

        if ($this->has_breaking_change_quoted_defaults()) {

            $info->default_value = is_null($rawcolumn->column_default) ? null : trim($rawcolumn->column_default, "'");

            if ($info->default_value === 'NULL') {

                $info->default_value = null;

            }

        } else {

            $info->default_value = $rawcolumn->column_default;

        }

        $info->has_default    = !is_null($info->default_value);

        $info->not_null       = ($rawcolumn->is_nullable === 'NO');

        $info->primary_key    = ($rawcolumn->column_key === 'PRI');

        $info->binary         = false;

        $info->unsigned       = null;

        $info->auto_increment = false;

        $info->unique         = null;

        $info->scale          = null;

        if ($info->meta_type === 'C') {

            $info->max_length = $rawcolumn->character_maximum_length;

        } else if ($info->meta_type === 'I') {