Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
0.00% |
0 / 14 |
CRAP | |
0.00% |
0 / 133 |
| Connection | |
0.00% |
0 / 1 |
|
0.00% |
0 / 14 |
1332 | |
0.00% |
0 / 133 |
| __construct | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 5 |
|||
| query | |
0.00% |
0 / 1 |
12 | |
0.00% |
0 / 10 |
|||
| open | |
0.00% |
0 / 1 |
90 | |
0.00% |
0 / 46 |
|||
| serialize | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 6 |
|||
| __destruct | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 4 |
|||
| queryRange | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 2 |
|||
| queryTemporary | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 4 |
|||
| driver | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 2 |
|||
| databaseType | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 2 |
|||
| createDatabase | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 9 |
|||
| mapConditionOperator | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 2 |
|||
| nextId | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 8 |
|||
| nextIdDelete | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 7 |
|||
| popCommittableTransactions | |
0.00% |
0 / 1 |
56 | |
0.00% |
0 / 26 |
|||
| <?php | |
| /** | |
| * @file | |
| * Contains \Drupal\Core\Database\Driver\mysql\Connection. | |
| */ | |
| namespace Drupal\Core\Database\Driver\mysql; | |
| use Drupal\Core\Database\DatabaseExceptionWrapper; | |
| use Drupal\Core\Database\Database; | |
| use Drupal\Core\Database\DatabaseNotFoundException; | |
| use Drupal\Core\Database\TransactionCommitFailedException; | |
| use Drupal\Core\Database\DatabaseException; | |
| use Drupal\Core\Database\Connection as DatabaseConnection; | |
| use Drupal\Component\Utility\Unicode; | |
| /** | |
| * @addtogroup database | |
| * @{ | |
| */ | |
| /** | |
| * MySQL implementation of \Drupal\Core\Database\Connection. | |
| */ | |
| class Connection extends DatabaseConnection { | |
| /** | |
| * Error code for "Unknown database" error. | |
| */ | |
| const DATABASE_NOT_FOUND = 1049; | |
| /** | |
| * Error code for "Can't initialize character set" error. | |
| */ | |
| const UNSUPPORTED_CHARSET = 2019; | |
| /** | |
| * Driver-specific error code for "Unknown character set" error. | |
| */ | |
| const UNKNOWN_CHARSET = 1115; | |
| /** | |
| * SQLSTATE error code for "Syntax error or access rule violation". | |
| */ | |
| const SQLSTATE_SYNTAX_ERROR = 42000; | |
| /** | |
| * Flag to indicate if the cleanup function in __destruct() should run. | |
| * | |
| * @var bool | |
| */ | |
| protected $needsCleanup = FALSE; | |
| /** | |
| * The minimal possible value for the max_allowed_packet setting of MySQL. | |
| * | |
| * @link https://mariadb.com/kb/en/mariadb/server-system-variables/#max_allowed_packet | |
| * @link https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html#sysvar_max_allowed_packet | |
| * | |
| * @var int | |
| */ | |
| const MIN_MAX_ALLOWED_PACKET = 1024; | |
| /** | |
| * Constructs a Connection object. | |
| */ | |
| public function __construct(\PDO $connection, array $connection_options = array()) { | |
| parent::__construct($connection, $connection_options); | |
| // This driver defaults to transaction support, except if explicitly passed FALSE. | |
| $this->transactionSupport = !isset($connection_options['transactions']) || ($connection_options['transactions'] !== FALSE); | |
| // MySQL never supports transactional DDL. | |
| $this->transactionalDDLSupport = FALSE; | |
| $this->connectionOptions = $connection_options; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function query($query, array $args = array(), $options = array()) { | |
| try { | |
| return parent::query($query, $args, $options); | |
| } catch (DatabaseException $e) { | |
| if ($e->getPrevious()->errorInfo[1] == 1153) { | |
| // If a max_allowed_packet error occurs the message length is truncated. | |
| // This should prevent the error from recurring if the exception is | |
| // logged to the database using dblog or the like. | |
| $message = Unicode::truncateBytes($e->getMessage(), self::MIN_MAX_ALLOWED_PACKET); | |
| $e = new DatabaseExceptionWrapper($message, $e->getCode(), $e->getPrevious()); | |
| } | |
| throw $e; | |
| } | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public static function open(array &$connection_options = array()) { | |
| if (isset($connection_options['_dsn_utf8_fallback']) && $connection_options['_dsn_utf8_fallback'] === TRUE) { | |
| // Only used during the installer version check, as a fallback from utf8mb4. | |
| $charset = 'utf8'; | |
| } | |
| else { | |
| $charset = 'utf8mb4'; | |
| } | |
| // The DSN should use either a socket or a host/port. | |
| if (isset($connection_options['unix_socket'])) { | |
| $dsn = 'mysql:unix_socket=' . $connection_options['unix_socket']; | |
| } | |
| else { | |
| // Default to TCP connection on port 3306. | |
| $dsn = 'mysql:host=' . $connection_options['host'] . ';port=' . (empty($connection_options['port']) ? 3306 : $connection_options['port']); | |
| } | |
| // Character set is added to dsn to ensure PDO uses the proper character | |
| // set when escaping. This has security implications. See | |
| // https://www.drupal.org/node/1201452 for further discussion. | |
| $dsn .= ';charset=' . $charset; | |
| if (!empty($connection_options['database'])) { | |
| $dsn .= ';dbname=' . $connection_options['database']; | |
| } | |
| // Allow PDO options to be overridden. | |
| $connection_options += array( | |
| 'pdo' => array(), | |
| ); | |
| $connection_options['pdo'] += array( | |
| \PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION, | |
| // So we don't have to mess around with cursors and unbuffered queries by default. | |
| \PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => TRUE, | |
| // Make sure MySQL returns all matched rows on update queries including | |
| // rows that actually didn't have to be updated because the values didn't | |
| // change. This matches common behavior among other database systems. | |
| \PDO::MYSQL_ATTR_FOUND_ROWS => TRUE, | |
| // Because MySQL's prepared statements skip the query cache, because it's dumb. | |
| \PDO::ATTR_EMULATE_PREPARES => TRUE, | |
| ); | |
| if (defined('\PDO::MYSQL_ATTR_MULTI_STATEMENTS')) { | |
| // An added connection option in PHP 5.5.21 to optionally limit SQL to a | |
| // single statement like mysqli. | |
| $connection_options['pdo'] += [\PDO::MYSQL_ATTR_MULTI_STATEMENTS => FALSE]; | |
| } | |
| $pdo = new \PDO($dsn, $connection_options['username'], $connection_options['password'], $connection_options['pdo']); | |
| // Force MySQL to use the UTF-8 character set. Also set the collation, if a | |
| // certain one has been set; otherwise, MySQL defaults to | |
| // 'utf8mb4_general_ci' for utf8mb4. | |
| if (!empty($connection_options['collation'])) { | |
| $pdo->exec('SET NAMES ' . $charset . ' COLLATE ' . $connection_options['collation']); | |
| } | |
| else { | |
| $pdo->exec('SET NAMES ' . $charset); | |
| } | |
| // Set MySQL init_commands if not already defined. Default Drupal's MySQL | |
| // behavior to conform more closely to SQL standards. This allows Drupal | |
| // to run almost seamlessly on many different kinds of database systems. | |
| // These settings force MySQL to behave the same as postgresql, or sqlite | |
| // in regards to syntax interpretation and invalid data handling. See | |
| // https://www.drupal.org/node/344575 for further discussion. Also, as MySQL | |
| // 5.5 changed the meaning of TRADITIONAL we need to spell out the modes one | |
| // by one. | |
| $connection_options += array( | |
| 'init_commands' => array(), | |
| ); | |
| $connection_options['init_commands'] += array( | |
| 'sql_mode' => "SET sql_mode = 'ANSI,STRICT_TRANS_TABLES,STRICT_ALL_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,ONLY_FULL_GROUP_BY'", | |
| ); | |
| // Execute initial commands. | |
| foreach ($connection_options['init_commands'] as $sql) { | |
| $pdo->exec($sql); | |
| } | |
| return $pdo; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function serialize() { | |
| // Cleanup the connection, much like __destruct() does it as well. | |
| if ($this->needsCleanup) { | |
| $this->nextIdDelete(); | |
| } | |
| $this->needsCleanup = FALSE; | |
| return parent::serialize(); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function __destruct() { | |
| if ($this->needsCleanup) { | |
| $this->nextIdDelete(); | |
| } | |
| } | |
| public function queryRange($query, $from, $count, array $args = array(), array $options = array()) { | |
| return $this->query($query . ' LIMIT ' . (int) $from . ', ' . (int) $count, $args, $options); | |
| } | |
| public function queryTemporary($query, array $args = array(), array $options = array()) { | |
| $tablename = $this->generateTemporaryTableName(); | |
| $this->query('CREATE TEMPORARY TABLE {' . $tablename . '} Engine=MEMORY ' . $query, $args, $options); | |
| return $tablename; | |
| } | |
| public function driver() { | |
| return 'mysql'; | |
| } | |
| public function databaseType() { | |
| return 'mysql'; | |
| } | |
| /** | |
| * Overrides \Drupal\Core\Database\Connection::createDatabase(). | |
| * | |
| * @param string $database | |
| * The name of the database to create. | |
| * | |
| * @throws \Drupal\Core\Database\DatabaseNotFoundException | |
| */ | |
| public function createDatabase($database) { | |
| // Escape the database name. | |
| $database = Database::getConnection()->escapeDatabase($database); | |
| try { | |
| // Create the database and set it as active. | |
| $this->connection->exec("CREATE DATABASE $database"); | |
| $this->connection->exec("USE $database"); | |
| } | |
| catch (\Exception $e) { | |
| throw new DatabaseNotFoundException($e->getMessage()); | |
| } | |
| } | |
| public function mapConditionOperator($operator) { | |
| // We don't want to override any of the defaults. | |
| return NULL; | |
| } | |
| public function nextId($existing_id = 0) { | |
| $new_id = $this->query('INSERT INTO {sequences} () VALUES ()', array(), array('return' => Database::RETURN_INSERT_ID)); | |
| // This should only happen after an import or similar event. | |
| if ($existing_id >= $new_id) { | |
| // If we INSERT a value manually into the sequences table, on the next | |
| // INSERT, MySQL will generate a larger value. However, there is no way | |
| // of knowing whether this value already exists in the table. MySQL | |
| // provides an INSERT IGNORE which would work, but that can mask problems | |
| // other than duplicate keys. Instead, we use INSERT ... ON DUPLICATE KEY | |
| // UPDATE in such a way that the UPDATE does not do anything. This way, | |
| // duplicate keys do not generate errors but everything else does. | |
| $this->query('INSERT INTO {sequences} (value) VALUES (:value) ON DUPLICATE KEY UPDATE value = value', array(':value' => $existing_id)); | |
| $new_id = $this->query('INSERT INTO {sequences} () VALUES ()', array(), array('return' => Database::RETURN_INSERT_ID)); | |
| } | |
| $this->needsCleanup = TRUE; | |
| return $new_id; | |
| } | |
| public function nextIdDelete() { | |
| // While we want to clean up the table to keep it up from occupying too | |
| // much storage and memory, we must keep the highest value in the table | |
| // because InnoDB uses an in-memory auto-increment counter as long as the | |
| // server runs. When the server is stopped and restarted, InnoDB | |
| // reinitializes the counter for each table for the first INSERT to the | |
| // table based solely on values from the table so deleting all values would | |
| // be a problem in this case. Also, TRUNCATE resets the auto increment | |
| // counter. | |
| try { | |
| $max_id = $this->query('SELECT MAX(value) FROM {sequences}')->fetchField(); | |
| // We know we are using MySQL here, no need for the slower db_delete(). | |
| $this->query('DELETE FROM {sequences} WHERE value < :value', array(':value' => $max_id)); | |
| } | |
| // During testing, this function is called from shutdown with the | |
| // simpletest prefix stored in $this->connection, and those tables are gone | |
| // by the time shutdown is called so we need to ignore the database | |
| // errors. There is no problem with completely ignoring errors here: if | |
| // these queries fail, the sequence will work just fine, just use a bit | |
| // more database storage and memory. | |
| catch (DatabaseException $e) { | |
| } | |
| } | |
| /** | |
| * Overridden to work around issues to MySQL not supporting transactional DDL. | |
| */ | |
| protected function popCommittableTransactions() { | |
| // Commit all the committable layers. | |
| foreach (array_reverse($this->transactionLayers) as $name => $active) { | |
| // Stop once we found an active transaction. | |
| if ($active) { | |
| break; | |
| } | |
| // If there are no more layers left then we should commit. | |
| unset($this->transactionLayers[$name]); | |
| if (empty($this->transactionLayers)) { | |
| if (!$this->connection->commit()) { | |
| throw new TransactionCommitFailedException(); | |
| } | |
| } | |
| else { | |
| // Attempt to release this savepoint in the standard way. | |
| try { | |
| $this->query('RELEASE SAVEPOINT ' . $name); | |
| } | |
| catch (DatabaseExceptionWrapper $e) { | |
| // However, in MySQL (InnoDB), savepoints are automatically committed | |
| // when tables are altered or created (DDL transactions are not | |
| // supported). This can cause exceptions due to trying to release | |
| // savepoints which no longer exist. | |
| // | |
| // To avoid exceptions when no actual error has occurred, we silently | |
| // succeed for MySQL error code 1305 ("SAVEPOINT does not exist"). | |
| if ($e->getPrevious()->errorInfo[1] == '1305') { | |
| // If one SAVEPOINT was released automatically, then all were. | |
| // Therefore, clean the transaction stack. | |
| $this->transactionLayers = array(); | |
| // We also have to explain to PDO that the transaction stack has | |
| // been cleaned-up. | |
| $this->connection->commit(); | |
| } | |
| else { | |
| throw $e; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * @} End of "addtogroup database". | |
| */ |