vendor/doctrine/dbal/src/Schema/MySQLSchemaManager.php line 334

Open in your IDE?
  1. <?php
  3. namespace Doctrine\DBAL\Schema;
  5. use Doctrine\DBAL\Platforms\AbstractMySQLPlatform;
  6. use Doctrine\DBAL\Platforms\MariaDb1027Platform;
  7. use Doctrine\DBAL\Platforms\MySQL;
  8. use Doctrine\DBAL\Types\Type;
  10. use function array_change_key_case;
  11. use function array_shift;
  12. use function assert;
  13. use function explode;
  14. use function is_string;
  15. use function preg_match;
  16. use function strpos;
  17. use function strtok;
  18. use function strtolower;
  19. use function strtr;
  21. use const CASE_LOWER;
  23. /**
  24.  * Schema manager for the MySQL RDBMS.
  25.  *
  26.  * @extends AbstractSchemaManager<AbstractMySQLPlatform>
  27.  */
  28. class MySQLSchemaManager extends AbstractSchemaManager
  29. {
  30.     /**
  31.      * @see https://mariadb.com/kb/en/library/string-literals/#escape-sequences
  32.      */
  33.     private const MARIADB_ESCAPE_SEQUENCES = [
  34.         '\\0' => "\0",
  35.         "\\'" => "'",
  36.         '\\"' => '"',
  37.         '\\b' => "\b",
  38.         '\\n' => "\n",
  39.         '\\r' => "\r",
  40.         '\\t' => "\t",
  41.         '\\Z' => "\x1a",
  42.         '\\\\' => '\\',
  43.         '\\%' => '%',
  44.         '\\_' => '_',
  46.         // Internally, MariaDB escapes single quotes using the standard syntax
  47.         "''" => "'",
  48.     ];
  50.     /**
  51.      * {@inheritdoc}
  52.      */
  53.     protected function _getPortableViewDefinition($view)
  54.     {
  55.         return new View($view['TABLE_NAME'], $view['VIEW_DEFINITION']);
  56.     }
  58.     /**
  59.      * {@inheritdoc}
  60.      */
  61.     protected function _getPortableTableDefinition($table)
  62.     {
  63.         return array_shift($table);
  64.     }
  66.     /**
  67.      * {@inheritdoc}
  68.      */
  69.     protected function _getPortableUserDefinition($user)
  70.     {
  71.         return [
  72.             'user' => $user['User'],
  73.             'password' => $user['Password'],
  74.         ];
  75.     }
  77.     /**
  78.      * {@inheritdoc}
  79.      */
  80.     protected function _getPortableTableIndexesList($tableIndexes, $tableName = null)
  81.     {
  82.         foreach ($tableIndexes as $k => $v) {
  83.             $v = array_change_key_case($v, CASE_LOWER);
  84.             if ($v['key_name'] === 'PRIMARY') {
  85.                 $v['primary'] = true;
  86.             } else {
  87.                 $v['primary'] = false;
  88.             }
  90.             if (strpos($v['index_type'], 'FULLTEXT') !== false) {
  91.                 $v['flags'] = ['FULLTEXT'];
  92.             } elseif (strpos($v['index_type'], 'SPATIAL') !== false) {
  93.                 $v['flags'] = ['SPATIAL'];
  94.             }
  96.             // Ignore prohibited prefix `length` for spatial index
  97.             if (strpos($v['index_type'], 'SPATIAL') === false) {
  98.                 $v['length'] = isset($v['sub_part']) ? (int) $v['sub_part'] : null;
  99.             }
  101.             $tableIndexes[$k] = $v;
  102.         }
  104.         return parent::_getPortableTableIndexesList($tableIndexes, $tableName);
  105.     }
  107.     /**
  108.      * {@inheritdoc}
  109.      */
  110.     protected function _getPortableDatabaseDefinition($database)
  111.     {
  112.         return $database['Database'];
  113.     }
  115.     /**
  116.      * {@inheritdoc}
  117.      */
  118.     protected function _getPortableTableColumnDefinition($tableColumn)
  119.     {
  120.         $tableColumn = array_change_key_case($tableColumn, CASE_LOWER);
  122.         $dbType = strtolower($tableColumn['type']);
  123.         $dbType = strtok($dbType, '(), ');
  124.         assert(is_string($dbType));
  126.         $length = $tableColumn['length'] ?? strtok('(), ');
  128.         $fixed = null;
  130.         if (! isset($tableColumn['name'])) {
  131.             $tableColumn['name'] = '';
  132.         }
  134.         $scale     = null;
  135.         $precision = null;
  137.         $type = $this->_platform->getDoctrineTypeMapping($dbType);
  139.         // In cases where not connected to a database DESCRIBE $table does not return 'Comment'
  140.         if (isset($tableColumn['comment'])) {
  141.             $type                   = $this->extractDoctrineTypeFromComment($tableColumn['comment'], $type);
  142.             $tableColumn['comment'] = $this->removeDoctrineTypeFromComment($tableColumn['comment'], $type);
  143.         }
  145.         switch ($dbType) {
  146.             case 'char':
  147.             case 'binary':
  148.                 $fixed = true;
  149.                 break;
  151.             case 'float':
  152.             case 'double':
  153.             case 'real':
  154.             case 'numeric':
  155.             case 'decimal':
  156.                 if (
  157.                     preg_match(
  158.                         '([A-Za-z]+\(([0-9]+),([0-9]+)\))',
  159.                         $tableColumn['type'],
  160.                         $match
  161.                     ) === 1
  162.                 ) {
  163.                     $precision = $match[1];
  164.                     $scale     = $match[2];
  165.                     $length    = null;
  166.                 }
  168.                 break;
  170.             case 'tinytext':
  171.                 $length = AbstractMySQLPlatform::LENGTH_LIMIT_TINYTEXT;
  172.                 break;
  174.             case 'text':
  175.                 $length = AbstractMySQLPlatform::LENGTH_LIMIT_TEXT;
  176.                 break;
  178.             case 'mediumtext':
  179.                 $length = AbstractMySQLPlatform::LENGTH_LIMIT_MEDIUMTEXT;
  180.                 break;
  182.             case 'tinyblob':
  183.                 $length = AbstractMySQLPlatform::LENGTH_LIMIT_TINYBLOB;
  184.                 break;
  186.             case 'blob':
  187.                 $length = AbstractMySQLPlatform::LENGTH_LIMIT_BLOB;
  188.                 break;
  190.             case 'mediumblob':
  191.                 $length = AbstractMySQLPlatform::LENGTH_LIMIT_MEDIUMBLOB;
  192.                 break;
  194.             case 'tinyint':
  195.             case 'smallint':
  196.             case 'mediumint':
  197.             case 'int':
  198.             case 'integer':
  199.             case 'bigint':
  200.             case 'year':
  201.                 $length = null;
  202.                 break;
  203.         }
  205.         if ($this->_platform instanceof MariaDb1027Platform) {
  206.             $columnDefault = $this->getMariaDb1027ColumnDefault($this->_platform, $tableColumn['default']);
  207.         } else {
  208.             $columnDefault = $tableColumn['default'];
  209.         }
  211.         $options = [
  212.             'length'        => $length !== null ? (int) $length : null,
  213.             'unsigned'      => strpos($tableColumn['type'], 'unsigned') !== false,
  214.             'fixed'         => (bool) $fixed,
  215.             'default'       => $columnDefault,
  216.             'notnull'       => $tableColumn['null'] !== 'YES',
  217.             'scale'         => null,
  218.             'precision'     => null,
  219.             'autoincrement' => strpos($tableColumn['extra'], 'auto_increment') !== false,
  220.             'comment'       => isset($tableColumn['comment']) && $tableColumn['comment'] !== ''
  221.                 ? $tableColumn['comment']
  222.                 : null,
  223.         ];
  225.         if ($scale !== null && $precision !== null) {
  226.             $options['scale']     = (int) $scale;
  227.             $options['precision'] = (int) $precision;
  228.         }
  230.         $column = new Column($tableColumn['field'], Type::getType($type), $options);
  232.         if (isset($tableColumn['characterset'])) {
  233.             $column->setPlatformOption('charset', $tableColumn['characterset']);
  234.         }
  236.         if (isset($tableColumn['collation'])) {
  237.             $column->setPlatformOption('collation', $tableColumn['collation']);
  238.         }
  240.         return $column;
  241.     }
  243.     /**
  244.      * Return Doctrine/Mysql-compatible column default values for MariaDB 10.2.7+ servers.
  245.      *
  246.      * - Since MariaDb 10.2.7 column defaults stored in information_schema are now quoted
  247.      *   to distinguish them from expressions (see MDEV-10134).
  248.      * - CURRENT_TIMESTAMP, CURRENT_TIME, CURRENT_DATE are stored in information_schema
  249.      *   as current_timestamp(), currdate(), currtime()
  250.      * - Quoted 'NULL' is not enforced by Maria, it is technically possible to have
  251.      *   null in some circumstances (see https://jira.mariadb.org/browse/MDEV-14053)
  252.      * - \' is always stored as '' in information_schema (normalized)
  253.      *
  254.      * @link https://mariadb.com/kb/en/library/information-schema-columns-table/
  255.      * @link https://jira.mariadb.org/browse/MDEV-13132
  256.      *
  257.      * @param string|null $columnDefault default value as stored in information_schema for MariaDB >= 10.2.7
  258.      */
  259.     private function getMariaDb1027ColumnDefault(MariaDb1027Platform $platform, ?string $columnDefault): ?string
  260.     {
  261.         if ($columnDefault === 'NULL' || $columnDefault === null) {
  262.             return null;
  263.         }
  265.         if (preg_match('/^\'(.*)\'$/', $columnDefault, $matches) === 1) {
  266.             return strtr($matches[1], self::MARIADB_ESCAPE_SEQUENCES);
  267.         }
  269.         switch ($columnDefault) {
  270.             case 'current_timestamp()':
  271.                 return $platform->getCurrentTimestampSQL();
  273.             case 'curdate()':
  274.                 return $platform->getCurrentDateSQL();
  276.             case 'curtime()':
  277.                 return $platform->getCurrentTimeSQL();
  278.         }
  280.         return $columnDefault;
  281.     }
  283.     /**
  284.      * {@inheritdoc}
  285.      */
  286.     protected function _getPortableTableForeignKeysList($tableForeignKeys)
  287.     {
  288.         $list = [];
  289.         foreach ($tableForeignKeys as $value) {
  290.             $value = array_change_key_case($value, CASE_LOWER);
  291.             if (! isset($list[$value['constraint_name']])) {
  292.                 if (! isset($value['delete_rule']) || $value['delete_rule'] === 'RESTRICT') {
  293.                     $value['delete_rule'] = null;
  294.                 }
  296.                 if (! isset($value['update_rule']) || $value['update_rule'] === 'RESTRICT') {
  297.                     $value['update_rule'] = null;
  298.                 }
  300.                 $list[$value['constraint_name']] = [
  301.                     'name' => $value['constraint_name'],
  302.                     'local' => [],
  303.                     'foreign' => [],
  304.                     'foreignTable' => $value['referenced_table_name'],
  305.                     'onDelete' => $value['delete_rule'],
  306.                     'onUpdate' => $value['update_rule'],
  307.                 ];
  308.             }
  310.             $list[$value['constraint_name']]['local'][]   = $value['column_name'];
  311.             $list[$value['constraint_name']]['foreign'][] = $value['referenced_column_name'];
  312.         }
  314.         $result = [];
  315.         foreach ($list as $constraint) {
  316.             $result[] = new ForeignKeyConstraint(
  317.                 $constraint['local'],
  318.                 $constraint['foreignTable'],
  319.                 $constraint['foreign'],
  320.                 $constraint['name'],
  321.                 [
  322.                     'onDelete' => $constraint['onDelete'],
  323.                     'onUpdate' => $constraint['onUpdate'],
  324.                 ]
  325.             );
  326.         }
  328.         return $result;
  329.     }
  331.     /**
  332.      * {@inheritdoc}
  333.      */
  334.     public function listTableDetails($name)
  335.     {
  336.         $table = parent::listTableDetails($name);
  338.         $sql = $this->_platform->getListTableMetadataSQL($name);
  340.         $tableOptions = $this->_conn->fetchAssociative($sql);
  342.         if ($tableOptions === false) {
  343.             return $table;
  344.         }
  346.         $table->addOption('engine', $tableOptions['ENGINE']);
  348.         if ($tableOptions['TABLE_COLLATION'] !== null) {
  349.             $table->addOption('collation', $tableOptions['TABLE_COLLATION']);
  350.         }
  352.         $table->addOption('charset', $tableOptions['CHARACTER_SET_NAME']);
  354.         if ($tableOptions['AUTO_INCREMENT'] !== null) {
  355.             $table->addOption('autoincrement', $tableOptions['AUTO_INCREMENT']);
  356.         }
  358.         $table->addOption('comment', $tableOptions['TABLE_COMMENT']);
  359.         $table->addOption('create_options', $this->parseCreateOptions($tableOptions['CREATE_OPTIONS']));
  361.         return $table;
  362.     }
  364.     public function createComparator(): Comparator
  365.     {
  366.         return new MySQL\Comparator($this->getDatabasePlatform());
  367.     }
  369.     /**
  370.      * @return string[]|true[]
  371.      */
  372.     private function parseCreateOptions(?string $string): array
  373.     {
  374.         $options = [];
  376.         if ($string === null || $string === '') {
  377.             return $options;
  378.         }
  380.         foreach (explode(' ', $string) as $pair) {
  381.             $parts = explode('=', $pair, 2);
  383.             $options[$parts[0]] = $parts[1] ?? true;
  384.         }
  386.         return $options;
  387.     }
  388. }