| Current File : /home/pacjaorg/public_html/kmm/libraries/vendor/joomla/database/src/Mysqli/MysqliDriver.php |
<?php
/**
* Part of the Joomla Framework Database Package
*
* @copyright Copyright (C) 2005 - 2021 Open Source Matters, Inc. All rights reserved.
* @license GNU General Public License version 2 or later; see LICENSE
*/
namespace Joomla\Database\Mysqli;
use Joomla\Database\DatabaseDriver;
use Joomla\Database\DatabaseEvents;
use Joomla\Database\Event\ConnectionEvent;
use Joomla\Database\Exception\ConnectionFailureException;
use Joomla\Database\Exception\ExecutionFailureException;
use Joomla\Database\Exception\PrepareStatementFailureException;
use Joomla\Database\Exception\UnsupportedAdapterException;
use Joomla\Database\StatementInterface;
use Joomla\Database\UTF8MB4SupportInterface;
/**
* MySQLi Database Driver
*
* @link https://www.php.net/manual/en/book.mysqli.php
* @since 1.0
*/
class MysqliDriver extends DatabaseDriver implements UTF8MB4SupportInterface
{
/**
* The database connection resource.
*
* @var \mysqli
* @since 1.0
*/
protected $connection;
/**
* The name of the database driver.
*
* @var string
* @since 1.0
*/
public $name = 'mysqli';
/**
* The character(s) used to quote SQL statement names such as table names or field names, etc.
*
* If a single character string the same character is used for both sides of the quoted name, else the first character will be used for the
* opening quote and the second for the closing quote.
*
* @var string
* @since 1.0
*/
protected $nameQuote = '`';
/**
* The null or zero representation of a timestamp for the database driver.
*
* @var string
* @since 1.0
*/
protected $nullDate = '0000-00-00 00:00:00';
/**
* True if the database engine supports UTF-8 Multibyte (utf8mb4) character encoding.
*
* @var boolean
* @since 1.4.0
*/
protected $utf8mb4 = false;
/**
* True if the database engine is MariaDB.
*
* @var boolean
* @since 2.0.0
*/
protected $mariadb = false;
/**
* The minimum supported MySQL database version.
*
* @var string
* @since 1.0
*/
protected static $dbMinimum = '5.6';
/**
* The minimum supported MariaDB database version.
*
* @var string
* @since 2.0.0
*/
protected static $dbMinMariadb = '10.0';
/**
* Constructor.
*
* @param array $options List of options used to configure the connection
*
* @since 1.0
*/
public function __construct(array $options)
{
/**
* sql_mode to MySql 5.7.8+ default strict mode minus ONLY_FULL_GROUP_BY
*
* @link https://dev.mysql.com/doc/relnotes/mysql/5.7/en/news-5-7-8.html#mysqld-5-7-8-sql-mode
*/
$sqlModes = [
'STRICT_TRANS_TABLES',
'ERROR_FOR_DIVISION_BY_ZERO',
'NO_ENGINE_SUBSTITUTION',
];
// Get some basic values from the options.
$options['host'] = $options['host'] ?? 'localhost';
$options['user'] = $options['user'] ?? 'root';
$options['password'] = $options['password'] ?? '';
$options['database'] = $options['database'] ?? '';
$options['select'] = isset($options['select']) ? (bool) $options['select'] : true;
$options['port'] = isset($options['port']) ? (int) $options['port'] : null;
$options['socket'] = $options['socket'] ?? null;
$options['utf8mb4'] = isset($options['utf8mb4']) ? (bool) $options['utf8mb4'] : false;
$options['sqlModes'] = isset($options['sqlModes']) ? (array) $options['sqlModes'] : $sqlModes;
$options['ssl'] = isset($options['ssl']) ? $options['ssl'] : [];
if ($options['ssl'] !== [])
{
$options['ssl']['enable'] = isset($options['ssl']['enable']) ? $options['ssl']['enable'] : false;
$options['ssl']['cipher'] = isset($options['ssl']['cipher']) ? $options['ssl']['cipher'] : null;
$options['ssl']['ca'] = isset($options['ssl']['ca']) ? $options['ssl']['ca'] : null;
$options['ssl']['capath'] = isset($options['ssl']['capath']) ? $options['ssl']['capath'] : null;
$options['ssl']['key'] = isset($options['ssl']['key']) ? $options['ssl']['key'] : null;
$options['ssl']['cert'] = isset($options['ssl']['cert']) ? $options['ssl']['cert'] : null;
$options['ssl']['verify_server_cert'] = isset($options['ssl']['verify_server_cert']) ? $options['ssl']['verify_server_cert'] : null;
}
// Finalize initialisation.
parent::__construct($options);
}
/**
* Check if the database server is responsive.
*
* @param string $host The host name or IP address.
* @param int $port The port number. Optional; default is the MySQL default.
* @param int $initialWaitInSeconds The number of seconds to wait before pinging the server. Optional; default is 0 seconds.
* @param int $intervalWaitInSeconds The number of seconds to wait between pinging the server. Optional; default is 3 seconds.
* @param int $timeoutInSeconds The timeout in seconds for the server to respond. Optional; default is 1 second.
* @param int $retries The number of retries. Optional; default is 3.
*
* @return boolean
* @todo This should maybe be moved to the parent class.
*
*/
public function healthCheck(string $host,
int $port = 3306,
int $initialWaitInSeconds = 0,
int $intervalWaitInSeconds = 3,
int $timeoutInSeconds = 1,
int $retries = 3
): bool
{
sleep($initialWaitInSeconds);
for ($i = 0; $i < $retries; $i++)
{
$file = @fsockopen($host, $port, $errno, $errstr, $timeoutInSeconds);
if ($file)
{
fclose($file);
return true;
}
sleep($intervalWaitInSeconds);
}
return false;
}
/**
* Connects to the database if needed.
*
* @return void Returns void if the database connected successfully.
*
* @since 1.0
* @throws \RuntimeException
*/
public function connect()
{
if ($this->connection)
{
return;
}
// Make sure the MySQLi extension for PHP is installed and enabled.
if (!static::isSupported())
{
throw new UnsupportedAdapterException('The MySQLi extension is not available');
}
/*
* Unlike mysql_connect(), mysqli_connect() takes the port and socket as separate arguments. Therefore, we
* have to extract them from the host string.
*/
$port = isset($this->options['port']) ? $this->options['port'] : 3306;
if (preg_match('/^unix:(?P<socket>[^:]+)$/', $this->options['host'], $matches))
{
// UNIX socket URI, e.g. 'unix:/path/to/unix/socket.sock'
$this->options['host'] = null;
$this->options['socket'] = $matches['socket'];
$this->options['port'] = null;
}
elseif (preg_match(
'/^(?P<host>((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))(:(?P<port>.+))?$/',
$this->options['host'],
$matches
))
{
// It's an IPv4 address with or without port
$this->options['host'] = $matches['host'];
if (!empty($matches['port']))
{
$port = $matches['port'];
}
}
elseif (preg_match('/^(?P<host>\[.*\])(:(?P<port>.+))?$/', $this->options['host'], $matches))
{
// We assume square-bracketed IPv6 address with or without port, e.g. [fe80:102::2%eth1]:3306
$this->options['host'] = $matches['host'];
if (!empty($matches['port']))
{
$port = $matches['port'];
}
}
elseif (preg_match('/^(?P<host>(\w+:\/{2,3})?[a-z0-9\.\-]+)(:(?P<port>[^:]+))?$/i', $this->options['host'], $matches))
{
// Named host (e.g example.com or localhost) with or without port
$this->options['host'] = $matches['host'];
if (!empty($matches['port']))
{
$port = $matches['port'];
}
}
elseif (preg_match('/^:(?P<port>[^:]+)$/', $this->options['host'], $matches))
{
// Empty host, just port, e.g. ':3306'
$this->options['host'] = 'localhost';
$port = $matches['port'];
}
// ... else we assume normal (naked) IPv6 address, so host and port stay as they are or default
// Get the port number or socket name
if (is_numeric($port))
{
$this->options['port'] = (int) $port;
}
else
{
$this->options['socket'] = $port;
}
$this->connection = mysqli_init();
$connectionFlags = 0;
// For SSL/TLS connection encryption.
if ($this->options['ssl'] !== [] && $this->options['ssl']['enable'] === true)
{
$connectionFlags += MYSQLI_CLIENT_SSL;
// Verify server certificate is only available in PHP 5.6.16+. See https://www.php.net/ChangeLog-5.php#5.6.16
if (isset($this->options['ssl']['verify_server_cert']))
{
// New constants in PHP 5.6.16+. See https://www.php.net/ChangeLog-5.php#5.6.16
if ($this->options['ssl']['verify_server_cert'] === true && defined('MYSQLI_CLIENT_SSL_VERIFY_SERVER_CERT'))
{
$connectionFlags += MYSQLI_CLIENT_SSL_VERIFY_SERVER_CERT;
}
elseif ($this->options['ssl']['verify_server_cert'] === false && defined('MYSQLI_CLIENT_SSL_DONT_VERIFY_SERVER_CERT'))
{
$connectionFlags += MYSQLI_CLIENT_SSL_DONT_VERIFY_SERVER_CERT;
}
elseif (defined('MYSQLI_OPT_SSL_VERIFY_SERVER_CERT'))
{
$this->connection->options(MYSQLI_OPT_SSL_VERIFY_SERVER_CERT, $this->options['ssl']['verify_server_cert']);
}
}
// Add SSL/TLS options only if changed.
$this->connection->ssl_set(
$this->options['ssl']['key'],
$this->options['ssl']['cert'],
$this->options['ssl']['ca'],
$this->options['ssl']['capath'],
$this->options['ssl']['cipher']
);
}
// Attempt to connect to the server, use error suppression to silence warnings and allow us to throw an Exception separately.
$connected = @$this->connection->real_connect(
$this->options['host'],
$this->options['user'],
$this->options['password'],
null,
$this->options['port'],
$this->options['socket'],
$connectionFlags
);
if (!$connected)
{
throw new ConnectionFailureException(
'Could not connect to database: ' . $this->connection->connect_error,
$this->connection->connect_errno
);
}
// If needed, set the sql modes.
if ($this->options['sqlModes'] !== [])
{
$this->connection->query('SET @@SESSION.sql_mode = \'' . implode(',', $this->options['sqlModes']) . '\';');
}
// And read the real sql mode to mitigate changes in mysql > 5.7.+
$this->options['sqlModes'] = explode(',', $this->setQuery('SELECT @@SESSION.sql_mode;')->loadResult());
// If auto-select is enabled select the given database.
if ($this->options['select'] && !empty($this->options['database']))
{
$this->select($this->options['database']);
}
$this->mariadb = stripos($this->connection->server_info, 'mariadb') !== false;
$this->utf8mb4 = $this->serverClaimsUtf8mb4Support();
// Set character sets (needed for MySQL 4.1.2+ and MariaDB).
$this->utf = $this->setUtf();
$this->dispatchEvent(new ConnectionEvent(DatabaseEvents::POST_CONNECT, $this));
}
/**
* Automatically downgrade a CREATE TABLE or ALTER TABLE query from utf8mb4 (UTF-8 Multibyte) to plain utf8.
*
* Used when the server doesn't support UTF-8 Multibyte.
*
* @param string $query The query to convert
*
* @return string The converted query
*
* @since 1.4.0
*/
public function convertUtf8mb4QueryToUtf8($query)
{
if ($this->utf8mb4)
{
return $query;
}
// If it's not an ALTER TABLE or CREATE TABLE command there's nothing to convert
if (!preg_match('/^(ALTER|CREATE)\s+TABLE\s+/i', $query))
{
return $query;
}
// Don't do preg replacement if string does not exist
if (stripos($query, 'utf8mb4') === false)
{
return $query;
}
// Replace utf8mb4 with utf8 if not within single or double quotes or name quotes
return preg_replace('/[`"\'][^`"\']*[`"\'](*SKIP)(*FAIL)|utf8mb4/i', 'utf8', $query);
}
/**
* Disconnects the database.
*
* @return void
*
* @since 1.0
*/
public function disconnect()
{
// Close the connection.
if (\is_callable($this->connection, 'close'))
{
$this->connection->close();
}
parent::disconnect();
}
/**
* Method to escape a string for usage in an SQL statement.
*
* @param string $text The string to be escaped.
* @param boolean $extra Optional parameter to provide extra escaping.
*
* @return string The escaped string.
*
* @since 1.0
*/
public function escape($text, $extra = false)
{
if (\is_int($text))
{
return $text;
}
if (\is_float($text))
{
// Force the dot as a decimal point.
return str_replace(',', '.', (string) $text);
}
$this->connect();
$result = $this->connection->real_escape_string((string) $text);
if ($extra)
{
$result = addcslashes($result, '%_');
}
return $result;
}
/**
* Test to see if the MySQLi connector is available.
*
* @return boolean True on success, false otherwise.
*
* @since 1.0
*/
public static function isSupported()
{
return \extension_loaded('mysqli');
}
/**
* Determines if the connection to the server is active.
*
* @return boolean True if connected to the database engine.
*
* @since 1.0
*/
public function connected()
{
if (\is_object($this->connection))
{
return $this->connection->ping();
}
return false;
}
/**
* Return the query string to alter the database character set.
*
* @param string $dbName The database name
*
* @return string The query that alter the database query string
*
* @since 2.0.0
*/
public function getAlterDbCharacterSet($dbName)
{
$charset = $this->utf8mb4 ? 'utf8mb4' : 'utf8';
return 'ALTER DATABASE ' . $this->quoteName($dbName) . ' CHARACTER SET `' . $charset . '`';
}
/**
* Method to get the database collation in use by sampling a text field of a table in the database.
*
* @return string|boolean The collation in use by the database (string) or boolean false if not supported.
*
* @since 1.0
* @throws \RuntimeException
*/
public function getCollation()
{
$this->connect();
return $this->setQuery('SELECT @@collation_database;')->loadResult();
}
/**
* Method to get the database connection collation in use by sampling a text field of a table in the database.
*
* @return string|boolean The collation in use by the database connection (string) or boolean false if not supported.
*
* @since 1.6.0
* @throws \RuntimeException
*/
public function getConnectionCollation()
{
$this->connect();
return $this->setQuery('SELECT @@collation_connection;')->loadResult();
}
/**
* Method to get the database encryption details (cipher and protocol) in use.
*
* @return string The database encryption details.
*
* @since 2.0.0
* @throws \RuntimeException
*/
public function getConnectionEncryption(): string
{
$this->connect();
$variables = $this->setQuery('SHOW SESSION STATUS WHERE `Variable_name` IN (\'Ssl_version\', \'Ssl_cipher\')')
->loadObjectList('Variable_name');
if (!empty($variables['Ssl_cipher']->Value))
{
return $variables['Ssl_version']->Value . ' (' . $variables['Ssl_cipher']->Value . ')';
}
return '';
}
/**
* Method to test if the database TLS connections encryption are supported.
*
* @return boolean Whether the database supports TLS connections encryption.
*
* @since 2.0.0
*/
public function isConnectionEncryptionSupported(): bool
{
$this->connect();
$variables = $this->setQuery('SHOW SESSION VARIABLES WHERE `Variable_name` IN (\'have_ssl\')')->loadObjectList('Variable_name');
return !empty($variables['have_ssl']->Value) && $variables['have_ssl']->Value === 'YES';
}
/**
* Return the query string to create new Database.
*
* @param \stdClass $options Object used to pass user and database name to database driver. This object must have "db_name" and "db_user" set.
* @param boolean $utf True if the database supports the UTF-8 character set.
*
* @return string The query that creates database
*
* @since 2.0.0
*/
protected function getCreateDatabaseQuery($options, $utf)
{
if ($utf)
{
$charset = $this->utf8mb4 ? 'utf8mb4' : 'utf8';
$collation = $charset . '_unicode_ci';
return 'CREATE DATABASE ' . $this->quoteName($options->db_name) . ' CHARACTER SET `' . $charset . '` COLLATE `' . $collation . '`';
}
return 'CREATE DATABASE ' . $this->quoteName($options->db_name);
}
/**
* Shows the table CREATE statement that creates the given tables.
*
* @param mixed $tables A table name or a list of table names.
*
* @return array A list of the create SQL for the tables.
*
* @since 1.0
* @throws \RuntimeException
*/
public function getTableCreate($tables)
{
$this->connect();
$result = [];
// Sanitize input to an array and iterate over the list.
$tables = (array) $tables;
foreach ($tables as $table)
{
// Set the query to get the table CREATE statement.
$row = $this->setQuery('SHOW CREATE TABLE ' . $this->quoteName($this->escape($table)))->loadRow();
// Populate the result array based on the create statements.
$result[$table] = $row[1];
}
return $result;
}
/**
* Retrieves field information about a given table.
*
* @param string $table The name of the database table.
* @param boolean $typeOnly True to only return field types.
*
* @return array An array of fields for the database table.
*
* @since 1.0
* @throws \RuntimeException
*/
public function getTableColumns($table, $typeOnly = true)
{
$this->connect();
$result = [];
// Set the query to get the table fields statement.
$fields = $this->setQuery('SHOW FULL COLUMNS FROM ' . $this->quoteName($this->escape($table)))->loadObjectList();
// If we only want the type as the value add just that to the list.
if ($typeOnly)
{
foreach ($fields as $field)
{
$result[$field->Field] = preg_replace('/[(0-9)]/', '', $field->Type);
}
}
else
{
// If we want the whole field data object add that to the list.
foreach ($fields as $field)
{
$result[$field->Field] = $field;
}
}
return $result;
}
/**
* Get the details list of keys for a table.
*
* @param string $table The name of the table.
*
* @return array An array of the column specification for the table.
*
* @since 1.0
* @throws \RuntimeException
*/
public function getTableKeys($table)
{
$this->connect();
// Get the details columns information.
return $this->setQuery('SHOW KEYS FROM ' . $this->quoteName($table))->loadObjectList();
}
/**
* Method to get an array of all tables in the database.
*
* @return array An array of all the tables in the database.
*
* @since 1.0
* @throws \RuntimeException
*/
public function getTableList()
{
$this->connect();
// Set the query to get the tables statement.
return $this->setQuery('SHOW TABLES')->loadColumn();
}
/**
* Get the version of the database connector.
*
* @return string The database connector version.
*
* @since 1.0
*/
public function getVersion()
{
$this->connect();
if ($this->mariadb)
{
// MariaDB: Strip off any leading '5.5.5-', if present
return preg_replace('/^5\.5\.5-/', '', $this->connection->server_info);
}
return $this->connection->server_info;
}
/**
* Get the minimum supported database version.
*
* @return string
*
* @since 2.0.0
*/
public function getMinimum()
{
return $this->mariadb ? static::$dbMinMariadb : static::$dbMinimum;
}
/**
* Determine whether the database engine support the UTF-8 Multibyte (utf8mb4) character encoding.
*
* @return boolean True if the database engine supports UTF-8 Multibyte.
*
* @since 2.0.0
*/
public function hasUTF8mb4Support()
{
return $this->utf8mb4;
}
/**
* Determine if the database engine is MariaDB.
*
* @return boolean
*
* @since 2.0.0
*/
public function isMariaDb(): bool
{
$this->connect();
return $this->mariadb;
}
/**
* Method to get the auto-incremented value from the last INSERT statement.
*
* @return mixed The value of the auto-increment field from the last inserted row.
* If the value is greater than maximal int value, it will return a string.
*
* @since 1.0
*/
public function insertid()
{
$this->connect();
return $this->connection->insert_id;
}
/**
* Inserts a row into a table based on an object's properties.
*
* @param string $table The name of the database table to insert into.
* @param object $object A reference to an object whose public properties match the table fields.
* @param string $key The name of the primary key. If provided the object property is updated.
*
* @return boolean
*
* @since 2.0.0
* @throws \RuntimeException
*/
public function insertObject($table, &$object, $key = null)
{
$fields = [];
$values = [];
$tableColumns = $this->getTableColumns($table);
// Iterate over the object variables to build the query fields and values.
foreach (get_object_vars($object) as $k => $v)
{
// Skip columns that don't exist in the table.
if (!array_key_exists($k, $tableColumns))
{
continue;
}
// Only process non-null scalars.
if (\is_array($v) || \is_object($v) || $v === null)
{
continue;
}
// Ignore any internal fields.
if ($k[0] === '_')
{
continue;
}
// Ignore null datetime fields.
if ($tableColumns[$k] === 'datetime' && empty($v))
{
continue;
}
// Ignore null integer fields.
if (stristr($tableColumns[$k], 'int') !== false && $v === '')
{
continue;
}
// Prepare and sanitize the fields and values for the database query.
$fields[] = $this->quoteName($k);
$values[] = $this->quote($v);
}
// Create the base insert statement.
$query = $this->getQuery(true)
->insert($this->quoteName($table))
->columns($fields)
->values(implode(',', $values));
// Set the query and execute the insert.
$this->setQuery($query)->execute();
// Update the primary key if it exists.
$id = $this->insertid();
if ($key && $id && \is_string($key))
{
$object->$key = $id;
}
return true;
}
/**
* Locks a table in the database.
*
* @param string $table The name of the table to unlock.
*
* @return $this
*
* @since 1.0
* @throws \RuntimeException
*/
public function lockTable($table)
{
$this->executeUnpreparedQuery($this->replacePrefix('LOCK TABLES ' . $this->quoteName($table) . ' WRITE'));
return $this;
}
/**
* Renames a table in the database.
*
* @param string $oldTable The name of the table to be renamed
* @param string $newTable The new name for the table.
* @param string $backup Not used by MySQL.
* @param string $prefix Not used by MySQL.
*
* @return $this
*
* @since 1.0
* @throws \RuntimeException
*/
public function renameTable($oldTable, $newTable, $backup = null, $prefix = null)
{
$this->setQuery('RENAME TABLE ' . $oldTable . ' TO ' . $newTable)->execute();
return $this;
}
/**
* Select a database for use.
*
* @param string $database The name of the database to select for use.
*
* @return boolean True if the database was successfully selected.
*
* @since 1.0
* @throws \RuntimeException
*/
public function select($database)
{
$this->connect();
if (!$database)
{
return false;
}
if (!$this->connection->select_db($database))
{
throw new ConnectionFailureException('Could not connect to database.');
}
return true;
}
/**
* Set the connection to use UTF-8 character encoding.
*
* @return boolean True on success.
*
* @since 1.0
*/
public function setUtf()
{
// If UTF is not supported return false immediately
if (!$this->utf)
{
return false;
}
// Make sure we're connected to the server
$this->connect();
// Which charset should I use, plain utf8 or multibyte utf8mb4?
$charset = $this->utf8mb4 && $this->options['utf8mb4'] ? 'utf8mb4' : 'utf8';
$result = @$this->connection->set_charset($charset);
/*
* If I could not set the utf8mb4 charset then the server doesn't support utf8mb4 despite claiming otherwise. This happens on old MySQL
* server versions (less than 5.5.3) using the mysqlnd PHP driver. Since mysqlnd masks the server version and reports only its own we
* can not be sure if the server actually does support UTF-8 Multibyte (i.e. it's MySQL 5.5.3 or later). Since the utf8mb4 charset is
* undefined in this case we catch the error and determine that utf8mb4 is not supported!
*/
if (!$result && $this->utf8mb4 && $this->options['utf8mb4'])
{
$this->utf8mb4 = false;
$result = @$this->connection->set_charset('utf8');
}
return $result;
}
/**
* Method to commit a transaction.
*
* @param boolean $toSavepoint If true, commit to the last savepoint.
*
* @return void
*
* @since 1.0
* @throws \RuntimeException
*/
public function transactionCommit($toSavepoint = false)
{
if (!$toSavepoint || $this->transactionDepth <= 1)
{
$this->connect();
if ($this->connection->commit())
{
$this->transactionDepth = 0;
}
return;
}
$this->transactionDepth--;
}
/**
* Method to roll back a transaction.
*
* @param boolean $toSavepoint If true, rollback to the last savepoint.
*
* @return void
*
* @since 1.0
* @throws \RuntimeException
*/
public function transactionRollback($toSavepoint = false)
{
if (!$toSavepoint || $this->transactionDepth <= 1)
{
$this->connect();
if ($this->connection->rollback())
{
$this->transactionDepth = 0;
}
return;
}
$savepoint = 'SP_' . ($this->transactionDepth - 1);
if ($this->executeUnpreparedQuery('ROLLBACK TO SAVEPOINT ' . $this->quoteName($savepoint)))
{
$this->transactionDepth--;
}
}
/**
* Method to initialize a transaction.
*
* @param boolean $asSavepoint If true and a transaction is already active, a savepoint will be created.
*
* @return void
*
* @since 1.0
* @throws \RuntimeException
*/
public function transactionStart($asSavepoint = false)
{
$this->connect();
if (!$asSavepoint || !$this->transactionDepth)
{
if ($this->connection->begin_transaction())
{
$this->transactionDepth = 1;
}
return;
}
$savepoint = 'SP_' . $this->transactionDepth;
if ($this->connection->savepoint($savepoint))
{
$this->transactionDepth++;
}
}
/**
* Internal method to execute queries which cannot be run as prepared statements.
*
* @param string $sql SQL statement to execute.
*
* @return boolean
*
* @since 1.5.0
*/
protected function executeUnpreparedQuery($sql)
{
$this->connect();
$cursor = $this->connection->query($sql);
// If an error occurred handle it.
if (!$cursor)
{
$errorNum = (int) $this->connection->errno;
$errorMsg = (string) $this->connection->error;
// Check if the server was disconnected.
if (!$this->connected())
{
try
{
// Attempt to reconnect.
$this->connection = null;
$this->connect();
}
catch (ConnectionFailureException $e)
{
// If connect fails, ignore that exception and throw the normal exception.
throw new ExecutionFailureException($sql, $errorMsg, $errorNum);
}
// Since we were able to reconnect, run the query again.
return $this->executeUnpreparedQuery($sql);
}
// The server was not disconnected.
throw new ExecutionFailureException($sql, $errorMsg, $errorNum);
}
$this->freeResult();
if ($cursor instanceof \mysqli_result)
{
$cursor->free_result();
}
return true;
}
/**
* Prepares a SQL statement for execution
*
* @param string $query The SQL query to be prepared.
*
* @return StatementInterface
*
* @since 2.0.0
* @throws PrepareStatementFailureException
*/
protected function prepareStatement(string $query): StatementInterface
{
return new MysqliStatement($this->connection, $query);
}
/**
* Unlocks tables in the database.
*
* @return $this
*
* @since 1.0
* @throws \RuntimeException
*/
public function unlockTables()
{
$this->executeUnpreparedQuery('UNLOCK TABLES');
return $this;
}
/**
* Does the database server claim to have support for UTF-8 Multibyte (utf8mb4) collation?
*
* libmysql supports utf8mb4 since 5.5.3 (same version as the MySQL server). mysqlnd supports utf8mb4 since 5.0.9.
*
* @return boolean
*
* @since 1.4.0
*/
private function serverClaimsUtf8mb4Support()
{
$client_version = mysqli_get_client_info();
$server_version = $this->getVersion();
if (version_compare($server_version, '5.5.3', '<'))
{
return false;
}
if ($this->mariadb && version_compare($server_version, '10.0.0', '<'))
{
return false;
}
if (strpos($client_version, 'mysqlnd') !== false)
{
$client_version = preg_replace('/^\D+([\d.]+).*/', '$1', $client_version);
return version_compare($client_version, '5.0.9', '>=');
}
return version_compare($client_version, '5.5.3', '>=');
}
/**
* Get the null or zero representation of a timestamp for the database driver.
*
* @return string
*
* @since 2.0.0
*/
public function getNullDate()
{
// Check the session sql mode;
if (\in_array('NO_ZERO_DATE', $this->options['sqlModes']) !== false)
{
$this->nullDate = '1000-01-01 00:00:00';
}
return $this->nullDate;
}
}