Enum support

src/Schema/Column.php

@@ -19,6 +19,9 @@ class Column extends AbstractAsset
 
     protected ?int $_length = null;
 
+    /** @var string[] */
+    protected array $_members = [];
+
     protected ?int $_precision = null;
 
     protected int $_scale = 0;
@@ -219,6 +222,18 @@ public function setAutoincrement(bool $flag): self
         return $this;
     }
 
+    /** @return string[] */
+    public function getMembers(): array
+    {
+        return $this->_members;
+    }
+
+    /** @param string[] $members */
+    public function setMembers(array $members): void
+    {
+        $this->_members = $members;
+    }
+
     public function setComment(string $comment): self
     {
         $this->_comment = $comment;
@@ -240,6 +255,7 @@ public function toArray(): array
             'default'       => $this->_default,
             'notnull'       => $this->_notnull,
             'length'        => $this->_length,
+            'members'       => $this->_members,
             'precision'     => $this->_precision,
             'scale'         => $this->_scale,
             'fixed'         => $this->_fixed,

src/Schema/MySQLSchemaManager.php

@@ -22,6 +22,7 @@
 use function implode;
 use function is_string;
 use function preg_match;
+use function preg_match_all;
 use function str_contains;
 use function strtok;
 use function strtolower;
@@ -211,6 +212,10 @@
             'autoincrement' => str_contains($tableColumn['extra'], 'auto_increment'),
         ];
 
+        if ($dbType === 'enum' && preg_match_all("/'([^']+)'/", $tableColumn['type'], $members) !== false) {
+            $options['members'] = $members[1];
+        }
+
         if (isset($tableColumn['comment'])) {
             $options['comment'] = $tableColumn['comment'];
         }

src/Types/EnumType.php

@@ -0,0 +1,161 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Types;
+
+use BackedEnum;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
+use Doctrine\DBAL\Platforms\SQLitePlatform;
+use Doctrine\DBAL\Platforms\SQLServerPlatform;
+use Doctrine\DBAL\Types\Exception\InvalidFormat;
+use Doctrine\DBAL\Types\Exception\InvalidType;
+use Doctrine\DBAL\Types\Exception\ValueNotConvertible;
+use ReflectionClass;
+use Stringable;
+use Throwable;
+use UnitEnum;
+
+use function array_map;
+use function class_exists;
+use function enum_exists;
+use function implode;
+use function in_array;
+use function is_object;
+use function is_string;
+use function sprintf;
+
+final class EnumType extends Type
+{
+    public string $name = 'enum';
+
+    public ?string $enumClassname = null;
+
+    /** @var array<int, string> */
+    public array $members = [];
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getMappedDatabaseTypes(AbstractPlatform $platform): array
+    {
+        return [$this->name];
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
+    {
+        $values = implode(
+            ', ',
+            array_map(
+                static fn (string $value) => sprintf('\'%s\'', $value),
+                $column['members'] ?: $column['type']->members,
+            ),
+        );
+
+        return match (true) {
+            $platform instanceof SQLitePlatform => sprintf('TEXT CHECK(%s IN (%s))', $column['name'], $values),
+            $platform instanceof PostgreSQLPlatform, $platform instanceof SQLServerPlatform => sprintf('VARCHAR(255) CHECK(%s IN (%s))', $column['name'], $values),
+            default => sprintf('ENUM(%s)', $values),
+        };
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function convertToDatabaseValue($value, AbstractPlatform $platform): ?string
+    {
+        if ($value === null) {
+            return null;
+        }
+
+        if ($this->enumClassname === null) {
+            if (! is_string($value)) {
+                throw InvalidType::new($value, $this->name, ['null', 'string']);
+            }
+
+            if (! in_array($value, $this->members)) {
+                throw InvalidType::new($value, $this->name, ['null', 'string']);
+            }
+
+            return $value;
+        }
+
+        if (enum_exists($this->enumClassname)) {
+            if (! $value instanceof UnitEnum) {
+                throw InvalidType::new($value, $this->name, ['null', $this->enumClassname]);
+            }
+
+            if ($value instanceof BackedEnum) {
+                return (string) $value->value;
+            }
+
+            return $value->name;
+        }
+
+        if (is_object($value)) {
+            if ($value::class !== $this->enumClassname) {
+                throw InvalidType::new($value, $this->name, ['null', $this->enumClassname]);
+            }
+
+            if (! $value instanceof Stringable) {
+                throw new ConversionException(sprintf('Class %s must implement Stringable interface', $this->enumClassname));
+            }
+        }
+
+        return (string) $value;
+    }
+
+    public function convertToPHPValue(mixed $value, AbstractPlatform $platform): mixed
+    {
+        if ($value === null) {
+            return null;
+        }
+
+        if (! is_string($value)) {
+            throw InvalidFormat::new($value, $this->name, 'string');
+        }
+
+        if ($this->enumClassname === null) {
+            if (! in_array($value, $this->members)) {
+                throw ValueNotConvertible::new($value, $this->name);
+            }
+
+            return $value;
+        }
+
+        if (enum_exists($this->enumClassname)) {
+            foreach ($this->enumClassname::cases() as $case) {
+                if (($case instanceof BackedEnum && $value === $case->value) || $value === $case->name) {
+                    return $case;
+                }
+            }
+
+            throw ValueNotConvertible::new($value, $this->getInternalDocrineType());
+        }
+
+        if (class_exists($this->enumClassname)) {
+            $refl = new ReflectionClass($this->enumClassname);
+
+            try {
+                return $refl->newInstance($value);
+            } catch (Throwable $e) {
+                throw ValueNotConvertible::new($value, $this->getInternalDocrineType(), $e->getMessage(), $e);
+            }
+        }
+
+        throw new ConversionException(sprintf('Class %s does not exists', $this->enumClassname));
+    }
+
+    private function getInternalDocrineType(): string
+    {
+        if ($this->enumClassname) {
+            return sprintf('%s(%s)', $this->name, $this->enumClassname);
+        }
+
+        return sprintf('%s(%s)', $this->name, 'string');
+    }
+}

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

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

tests/Functional/Schema/ComparatorTestUtils.php

@@ -38,6 +38,16 @@
         );
     }
 
+    public static function assertNoDiffDetected(Connection $connection, Comparator $comparator, Table $table): void
+    {
+        $schemaManager = $connection->createSchemaManager();
+
+        $diff = self::diffFromActualToDesiredTable($schemaManager, $comparator, $table);
+        var_dump($diff->getModifiedColumns()[0]);
+
+        TestCase::assertTrue($diff->isEmpty());
+    }
+
     public static function assertDiffNotEmpty(Connection $connection, Comparator $comparator, Table $table): void
     {
         $schemaManager = $connection->createSchemaManager();

tests/Functional/Schema/MySQL/ComparatorTest.php

@@ -9,6 +9,7 @@
 use Doctrine\DBAL\Platforms\AbstractPlatform;
 use Doctrine\DBAL\Platforms\MariaDBPlatform;
 use Doctrine\DBAL\Platforms\MySQL80Platform;
+use Doctrine\DBAL\Platforms\MySQLPlatform;
 use Doctrine\DBAL\Schema\AbstractSchemaManager;
 use Doctrine\DBAL\Schema\Column;
 use Doctrine\DBAL\Schema\Comparator;
@@ -214,6 +215,22 @@
         ComparatorTestUtils::assertDiffNotEmpty($this->connection, $this->comparator, $table);
     }
 
+    public function testEnumDiffDetected(): void
+    {
+        $table = new Table('enum_test_table');
+
+        $table->addColumn('enum_col', Types::ENUM, ['members' => ['a', 'b']]);
+        $this->dropAndCreateTable($table);
+
+        ComparatorTestUtils::assertNoDiffDetected($this->connection, $this->comparator, $table);
+
+        // Alter column to previous state and check diff
+        $sql = 'ALTER TABLE enum_test_table CHANGE enum_col enum_col ENUM(\'NOT_A_MEMBER_ANYMORE\') NOT NULL';
+        $this->connection->executeStatement($sql);
+
+        ComparatorTestUtils::assertDiffNotEmpty($this->connection, $this->comparator, $table);
+    }
+
     /**
      * @return array{Table,Column}
      *

tests/Functional/Schema/Oracle/ComparatorTest.php

@@ -60,4 +60,20 @@ public function testChangeBinaryColumnFixed(): void
             $table,
         )->isEmpty());
     }
+
+    public function testEnumDiffDetected(): void
+    {
+        $table = new Table('enum_test_table');
+
+        $table->addColumn('enum_col', Types::ENUM, ['members' => ['a', 'b']]);
+        $this->dropAndCreateTable($table);
+
+        ComparatorTestUtils::assertNoDiffDetected($this->connection, $this->comparator, $table);
+
+        // Alter column to previous state and check diff
+        $sql = 'ALTER TABLE enum_test_table CHANGE enum_col enum_col ENUM(\'NOT_A_MEMBER_ANYMORE\') NOT NULL';
+        $this->connection->executeStatement($sql);
+
+        ComparatorTestUtils::assertDiffNotEmpty($this->connection, $this->comparator, $table);
+    }
 }

tests/Functional/Schema/PostgreSQL/ComparatorTest.php

@@ -92,4 +92,20 @@ private function testColumnModification(callable $addColumn, callable $modifyCol
             $table,
         )->isEmpty());
     }
+
+    public function testEnumDiffDetected(): void
+    {
+        $table = new Table('enum_test_table');
+
+        $table->addColumn('enum_col', Types::ENUM, ['members' => ['a', 'b']]);
+        $this->dropAndCreateTable($table);
+
+        ComparatorTestUtils::assertNoDiffDetected($this->connection, $this->comparator, $table);
+
+        // Alter column to previous state and check diff
+        $sql = 'ALTER TABLE enum_test_table CHANGE enum_col enum_col ENUM(\'NOT_A_MEMBER_ANYMORE\') NOT NULL';
+        $this->connection->executeStatement($sql);
+
+        ComparatorTestUtils::assertDiffNotEmpty($this->connection, $this->comparator, $table);
+    }
 }

tests/Functional/Schema/SQLite/ComparatorTest.php

@@ -42,4 +42,14 @@ public function testChangeTableCollation(): void
         $column->setPlatformOption('collation', 'NOCASE');
         ComparatorTestUtils::assertDiffNotEmpty($this->connection, $this->comparator, $table);
     }
+
+    public function testEnumColumnIsCreated(): void
+    {
+        $table = new Table('enum_test_table');
+
+        $table->addColumn('enum_col', Types::ENUM, ['members' => ['a', 'b']]);
+        $this->dropAndCreateTable($table);
+
+        ComparatorTestUtils::assertNoDiffDetected($this->connection, $this->comparator, $table);
+    }
 }

tests/Functional/Types/EnumTest.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Tests\Functional\Types;
+
+use Doctrine\DBAL\Schema\Table;
+use Doctrine\DBAL\Tests\FunctionalTestCase;
+use Doctrine\DBAL\Types\Types;
+
+class EnumTest extends FunctionalTestCase
+{
+    protected function setUp(): void
+    {
+        $table = new Table('enum_table');
+        $table->addColumn('val', Types::ENUM, ['members' => ['a', 'b']]);
+
+        $this->dropAndCreateTable($table);
+    }
+
+    public function testInsertAndSelect(): void
+    {
+        $val = 'b';
+
+        $result = $this->connection->insert('enum_table', ['val' => $val]);
+        self::assertSame(1, $result);
+
+        $value = $this->connection->fetchOne('SELECT val FROM enum_table');
+
+        self::assertEquals($val, $value);
+    }
+}

tests/Schema/ColumnTest.php

@@ -45,6 +45,7 @@ public function testToArray(): void
             'default' => 'baz',
             'notnull' => false,
             'length' => 200,
+            'members' => [],
             'precision' => 5,
             'scale' => 2,
             'fixed' => true,
@@ -148,4 +149,17 @@ public function testColumnComment(): void
         self::assertArrayHasKey('comment', $columnArray);
         self::assertEquals('foo', $columnArray['comment']);
     }
+
+    public function testEnumMembers(): void
+    {
+        $column = new Column('bar', Type::getType(Types::ENUM));
+        self::assertSame([], $column->getMembers());
+
+        $column->setMembers(['a', 'b']);
+        self::assertEquals(['a', 'b'], $column->getMembers());
+
+        $columnArray = $column->toArray();
+        self::assertArrayHasKey('members', $columnArray);
+        self::assertEquals(['a', 'b'], $columnArray['members']);
+    }
 }