Implement an EnumType for MySQL/MariaDB

src/Platforms/AbstractMySQLPlatform.php

@@ -17,13 +17,16 @@
 use Doctrine\DBAL\SQL\Builder\SelectSQLBuilder;
 use Doctrine\DBAL\TransactionIsolationLevel;
 use Doctrine\DBAL\Types\Types;
+use RuntimeException;
 
+use function array_map;
 use function array_merge;
 use function array_unique;
 use function array_values;
 use function count;
 use function implode;
 use function in_array;
+use function is_array;
 use function is_numeric;
 use function sprintf;
 use function str_replace;
@@ -645,6 +648,21 @@ public function getDecimalTypeDeclarationSQL(array $column): string
         return parent::getDecimalTypeDeclarationSQL($column) . $this->getUnsignedDeclaration($column);
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    public function getEnumDeclarationSQL(array $column): string
+    {
+        if (empty($column['values']) || ! is_array($column['values'])) {
+            throw new RuntimeException('Incomplete ENUM column definition. ENUM columns require an array of values.');
+        }
+
+        return sprintf('ENUM(%s)', implode(', ', array_map(
+            $this->quoteStringLiteral(...),
+            $column['values'],
+        )));
+    }
+
     /**
      * Get unsigned declaration for a column.
      *
@@ -718,6 +736,7 @@ protected function initializeDoctrineTypeMappings(): void
             'datetime'   => Types::DATETIME_MUTABLE,
             'decimal'    => Types::DECIMAL,
             'double'     => Types::FLOAT,
+            'enum'       => Types::ENUM,
             'float'      => Types::SMALLFLOAT,
             'int'        => Types::INTEGER,
             'integer'    => Types::INTEGER,

src/Platforms/AbstractPlatform.php

@@ -190,6 +190,19 @@ public function getBinaryTypeDeclarationSQL(array $column): string
         }
     }
 
+    /**
+     * Returns the SQL snippet to declare an ENUM column.
+     *
+     * Enum is a non-standard type that is espacially popular in MySQL and MariaDB. By default, this method throws
+     * because we assume that the platform does not support ENUM types.
+     *
+     * @param array<string, mixed> $column
+     */
+    public function getEnumDeclarationSQL(array $column): string
+    {
+        throw NotSupported::new(__METHOD__);
+    }
+
     /**
      * Returns the SQL snippet to declare a GUID/UUID column.
      *

src/Schema/Column.php

@@ -33,6 +33,9 @@ class Column extends AbstractAsset
 
     protected bool $_autoincrement = false;
 
+    /** @var list<string> */
+    protected array $_values = [];
+
     /** @var array<string, mixed> */
     protected array $_platformOptions = [];
 
@@ -231,22 +234,41 @@ public function getComment(): string
         return $this->_comment;
     }
 
+    /**
+     * @param list<string> $values
+     *
+     * @return $this
+     */
+    public function setValues(array $values): static
+    {
+        $this->_values = $values;
+
+        return $this;
+    }
+
+    /** @return list<string> */
+    public function getValues(): array
+    {
+        return $this->_values;
+    }
+
     /** @return array<string, mixed> */
     public function toArray(): array
     {
         return array_merge([
-            'name'          => $this->_name,
-            'type'          => $this->_type,
-            'default'       => $this->_default,
-            'notnull'       => $this->_notnull,
-            'length'        => $this->_length,
-            'precision'     => $this->_precision,
-            'scale'         => $this->_scale,
-            'fixed'         => $this->_fixed,
-            'unsigned'      => $this->_unsigned,
-            'autoincrement' => $this->_autoincrement,
+            'name'             => $this->_name,
+            'type'             => $this->_type,
+            'default'          => $this->_default,
+            'notnull'          => $this->_notnull,
+            'length'           => $this->_length,
+            'precision'        => $this->_precision,
+            'scale'            => $this->_scale,
+            'fixed'            => $this->_fixed,
+            'unsigned'         => $this->_unsigned,
+            'autoincrement'    => $this->_autoincrement,
             'columnDefinition' => $this->_columnDefinition,
-            'comment' => $this->_comment,
+            'comment'          => $this->_comment,
+            'values'           => $this->_values,
         ], $this->_platformOptions);
     }
 }

src/Schema/MySQLSchemaManager.php

@@ -26,6 +26,7 @@
 use function strtok;
 use function strtolower;
 use function strtr;
+use function substr;
 
 use const CASE_LOWER;
 
@@ -134,6 +135,8 @@ protected function _getPortableTableColumnDefinition(array $tableColumn): Column
 
         $type = $this->platform->getDoctrineTypeMapping($dbType);
 
+        $values = [];
+
         switch ($dbType) {
             case 'char':
             case 'binary':
@@ -192,6 +195,11 @@ protected function _getPortableTableColumnDefinition(array $tableColumn): Column
             case 'year':
                 $length = null;
                 break;
+
+            case 'enum':
+            case 'set':
+                $values = explode('\',\'', substr($tableColumn['type'], 6, -2));
+                break;
         }
 
         if ($this->platform instanceof MariaDBPlatform) {
@@ -209,6 +217,7 @@ protected function _getPortableTableColumnDefinition(array $tableColumn): Column
             'scale'         => $scale,
             'precision'     => $precision,
             'autoincrement' => str_contains($tableColumn['extra'], 'auto_increment'),
+            'values'        => $values,
         ];
 
         if (isset($tableColumn['comment'])) {

src/Types/EnumType.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Types;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+
+final class EnumType extends Type
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
+    {
+        return $platform->getEnumDeclarationSQL($column);
+    }
+}

src/Types/Type.php

@@ -34,6 +34,7 @@ abstract class Type
         Types::DATETIMETZ_MUTABLE   => DateTimeTzType::class,
         Types::DATETIMETZ_IMMUTABLE => DateTimeTzImmutableType::class,
         Types::DECIMAL              => DecimalType::class,
+        Types::ENUM                 => EnumType::class,
         Types::FLOAT                => FloatType::class,
         Types::GUID                 => GuidType::class,
         Types::INTEGER              => IntegerType::class,

src/Types/Types.php

@@ -23,6 +23,7 @@ final class Types
     public const DATETIMETZ_IMMUTABLE = 'datetimetz_immutable';
     public const DECIMAL              = 'decimal';
     public const FLOAT                = 'float';
+    public const ENUM                 = 'enum';
     public const GUID                 = 'guid';
     public const INTEGER              = 'integer';
     public const JSON                 = 'json';

tests/Functional/Schema/MySQLSchemaManagerTest.php

@@ -561,7 +561,10 @@ public function testColumnIntrospection(): void
         $doctrineTypes = array_keys(Type::getTypesMap());
 
         foreach ($doctrineTypes as $type) {
-            $table->addColumn('col_' . $type, $type, ['length' => 8, 'precision' => 8, 'scale' => 2]);
+            $table->addColumn('col_' . $type, $type, match ($type) {
+                Types::ENUM => ['values' => ['foo', 'bar']],
+                default => ['length' => 8, 'precision' => 8, 'scale' => 2],
+            });
         }
 
         $this->dropAndCreateTable($table);

tests/Functional/Types/EnumTypeTest.php

@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Tests\Functional\Types;
+
+use Doctrine\DBAL\Platforms\AbstractMySQLPlatform;
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\DBAL\Tests\FunctionalTestCase;
+use Doctrine\DBAL\Types\EnumType;
+use Doctrine\DBAL\Types\Type;
+use Doctrine\DBAL\Types\Types;
+
+final class EnumTypeTest extends FunctionalTestCase
+{
+    protected function setUp(): void
+    {
+        if (! $this->connection->getDatabasePlatform() instanceof AbstractMySQLPlatform) {
+            self::markTestSkipped('This test requires MySQL or MariaDB.');
+        }
+
+        $this->connection->executeStatement('DROP TABLE IF EXISTS my_enum_table');
+    }
+
+    public function testIntrospectEnum(): void
+    {
+        $this->connection->executeStatement(<<< 'SQL'
+            CREATE TABLE my_enum_table (
+                id BIGINT NOT NULL PRIMARY KEY,
+                suit ENUM('hearts', 'diamonds', 'clubs', 'spades') NOT NULL DEFAULT 'hearts'
+            );
+            SQL);
+
+        $schemaManager = $this->connection->createSchemaManager();
+        $table         = $schemaManager->introspectTable('my_enum_table');
+
+        self::assertCount(2, $table->getColumns());
+        self::assertTrue($table->hasColumn('suit'));
+        self::assertInstanceOf(EnumType::class, $table->getColumn('suit')->getType());
+        self::assertSame(['hearts', 'diamonds', 'clubs', 'spades'], $table->getColumn('suit')->getValues());
+        self::assertSame('hearts', $table->getColumn('suit')->getDefault());
+    }
+
+    public function testDeployEnum(): void
+    {
+        $schemaManager = $this->connection->createSchemaManager();
+        $schema        = new Schema(schemaConfig: $schemaManager->createSchemaConfig());
+        $table         = $schema->createTable('my_enum_table');
+        $table->addColumn('id', Types::BIGINT, ['notnull' => true]);
+        $table->addColumn('suit', Types::ENUM, [
+            'values' => ['hearts', 'diamonds', 'clubs', 'spades'],
+            'notnull' => true,
+            'default' => 'hearts',
+        ]);
+        $table->setPrimaryKey(['id']);
+
+        $schemaManager->createSchemaObjects($schema);
+
+        $introspectedTable = $schemaManager->introspectTable('my_enum_table');
+
+        self::assertTrue($schemaManager->createComparator()->compareTables($table, $introspectedTable)->isEmpty());
+
+        $this->connection->insert('my_enum_table', ['id' => 1, 'suit' => 'hearts'], ['suit' => Types::ENUM]);
+        $this->connection->insert('my_enum_table', ['id' => 2, 'suit' => 'diamonds'], ['suit' => Type::getType(Types::ENUM)]);
+
+        self::assertSame(
+            [['id' => 1, 'suit' => 'hearts'], ['id' => 2, 'suit' => 'diamonds']],
+            $this->connection->fetchAllAssociative('SELECT id, suit FROM my_enum_table'),
+        );
+    }
+}

tests/Schema/ColumnTest.php

@@ -52,6 +52,7 @@ public function testToArray(): void
             'autoincrement' => false,
             'columnDefinition' => null,
             'comment' => '',
+            'values' => [],
             'foo' => 'bar',
         ];