[8.x] Improve support for custom Doctrine column types

src/Illuminate/Database/Connection.php

@@ -5,6 +5,7 @@
 use Closure;
 use DateTimeInterface;
 use Doctrine\DBAL\Connection as DoctrineConnection;
+use Doctrine\DBAL\Types\Type;
 use Exception;
 use Illuminate\Contracts\Events\Dispatcher;
 use Illuminate\Database\Events\QueryExecuted;
@@ -21,6 +22,7 @@
 use LogicException;
 use PDO;
 use PDOStatement;
+use RuntimeException;
 
 class Connection implements ConnectionInterface
 {
@@ -1010,6 +1012,34 @@ public function getDoctrineConnection()
         return $this->doctrineConnection;
     }
 
+    /**
+     * Register a custom Doctrine mapping type.
+     *
+     * @param  string  $class
+     * @param  string  $name
+     * @param  string  $type
+     * @return void
+     *
+     * @throws \Doctrine\DBAL\DBALException
+     * @throws \RuntimeException
+     */
+    public function registerDoctrineType(string $class, string $name, string $type): void
+    {
+        if (! $this->isDoctrineAvailable()) {
+            throw new RuntimeException(
+                'Registering a custom Doctrine type requires Doctrine DBAL (doctrine/dbal).'
+            );
+        }
+
+        if (! Type::hasType($name)) {
+            Type::addType($name, $class);
+        }
+
+        $this->getDoctrineSchemaManager()
+            ->getDatabasePlatform()
+            ->registerDoctrineTypeMapping($type, $name);
+    }
+
     /**
      * Get the current PDO connection.
      *

src/Illuminate/Database/DBAL/TimestampType.php

@@ -2,10 +2,10 @@
 
 namespace Illuminate\Database\DBAL;
 
-use Doctrine\DBAL\DBALException;
 use Doctrine\DBAL\Platforms\AbstractPlatform;
 use Doctrine\DBAL\Types\PhpDateTimeMappingType;
 use Doctrine\DBAL\Types\Type;
+use RuntimeException;
 
 class TimestampType extends Type implements PhpDateTimeMappingType
 {
@@ -36,7 +36,7 @@ public function getSQLDeclaration(array $fieldDeclaration, AbstractPlatform $pla
                 return $this->getSQLitePlatformSQLDeclaration($fieldDeclaration);
 
             default:
-                throw new DBALException('Invalid platform: '.$name);
+                throw new RuntimeException('Invalid platform: '.$name);
         }
     }
 

src/Illuminate/Database/DatabaseManager.php

@@ -183,9 +183,24 @@ protected function configure(Connection $connection, $type)
         // the connection, which will allow us to reconnect from the connections.
         $connection->setReconnector($this->reconnector);
 
+        $this->registerConfiguredDoctrineTypes($connection);
+
         return $connection;
     }
 
+    /**
+     * Register custom Doctrine types from the config with the connection.
+     *
+     * @param  \Illuminate\Database\Connection  $connection
+     * @return void
+     */
+    protected function registerConfiguredDoctrineTypes(Connection $connection): void
+    {
+        foreach ($this->app['config']->get('database.dbal.types', []) as $name => $class) {
+            $connection->registerDoctrineType($class, $name, $name);
+        }
+    }
+
     /**
      * Prepare the read / write mode for database connection instance.
      *

src/Illuminate/Database/DatabaseServiceProvider.php

@@ -2,7 +2,6 @@
 
 namespace Illuminate\Database;
 
-use Doctrine\DBAL\Types\Type;
 use Faker\Factory as FakerFactory;
 use Faker\Generator as FakerGenerator;
 use Illuminate\Contracts\Queue\EntityResolver;
@@ -44,7 +43,6 @@ public function register()
         $this->registerConnectionServices();
         $this->registerEloquentFactory();
         $this->registerQueueableEntityResolver();
-        $this->registerDoctrineTypes();
     }
 
     /**
@@ -108,24 +106,4 @@ protected function registerQueueableEntityResolver()
             return new QueueEntityResolver;
         });
     }
-
-    /**
-     * Register custom types with the Doctrine DBAL library.
-     *
-     * @return void
-     */
-    protected function registerDoctrineTypes()
-    {
-        if (! class_exists(Type::class)) {
-            return;
-        }
-
-        $types = $this->app['config']->get('database.dbal.types', []);
-
-        foreach ($types as $name => $class) {
-            if (! Type::hasType($name)) {
-                Type::addType($name, $class);
-            }
-        }
-    }
 }

src/Illuminate/Database/Schema/Builder.php

@@ -3,11 +3,9 @@
 namespace Illuminate\Database\Schema;
 
 use Closure;
-use Doctrine\DBAL\Types\Type;
 use Illuminate\Database\Connection;
 use InvalidArgumentException;
 use LogicException;
-use RuntimeException;
 
 class Builder
 {
@@ -392,26 +390,10 @@ protected function createBlueprint($table, Closure $callback = null)
      * @param  string  $name
      * @param  string  $type
      * @return void
-     *
-     * @throws \Doctrine\DBAL\DBALException
-     * @throws \RuntimeException
      */
     public function registerCustomDoctrineType($class, $name, $type)
     {
-        if (! $this->connection->isDoctrineAvailable()) {
-            throw new RuntimeException(
-                'Registering a custom Doctrine type requires Doctrine DBAL (doctrine/dbal).'
-            );
-        }
-
-        if (! Type::hasType($name)) {
-            Type::addType($name, $class);
-
-            $this->connection
-                ->getDoctrineSchemaManager()
-                ->getDatabasePlatform()
-                ->registerDoctrineTypeMapping($type, $name);
-        }
+        $this->connection->registerDoctrineType($class, $name, $type);
     }
 
     /**

tests/Integration/Database/ConfigureCustomDoctrineTypeTest.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace Illuminate\Tests\Integration\Database\SchemaTest;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Types\Type;
+use Illuminate\Database\Grammar;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+use Illuminate\Tests\Integration\Database\DatabaseTestCase;
+
+class ConfigureCustomDoctrineTypeTest extends DatabaseTestCase
+{
+    protected function defineEnvironment($app)
+    {
+        $app['config']['database.connections.sqlite.database'] = ':memory:';
+        $app['config']['database.dbal.types'] = [
+            'bit' => MySQLBitType::class,
+            'xml' => PostgresXmlType::class,
+        ];
+    }
+
+    public function testRegisterCustomDoctrineTypesWithNonDefaultDatabaseConnections()
+    {
+        $this->assertTrue(
+            DB::connection()
+                ->getDoctrineSchemaManager()
+                ->getDatabasePlatform()
+                ->hasDoctrineTypeMappingFor('xml')
+        );
+
+        // Custom type mappings are registered for a connection when it's created,
+        // this is not the default connection but it has the custom type mappings
+        $this->assertTrue(
+            DB::connection('sqlite')
+                ->getDoctrineSchemaManager()
+                ->getDatabasePlatform()
+                ->hasDoctrineTypeMappingFor('xml')
+        );
+    }
+
+    public function testRenameConfiguredCustomDoctrineColumnTypeWithPostgres()
+    {
+        if ($this->driver !== 'pgsql') {
+            $this->markTestSkipped('Test requires a Postgres connection.');
+        }
+
+        Grammar::macro('typeXml', function () {
+            return 'xml';
+        });
+
+        Schema::create('test', function (Blueprint $table) {
+            $table->addColumn('xml', 'test_column');
+        });
+
+        Schema::table('test', function (Blueprint $table) {
+            $table->renameColumn('test_column', 'renamed_column');
+        });
+
+        $this->assertFalse(Schema::hasColumn('test', 'test_column'));
+        $this->assertTrue(Schema::hasColumn('test', 'renamed_column'));
+    }
+
+    public function testRenameConfiguredCustomDoctrineColumnTypeWithMysql()
+    {
+        if ($this->driver !== 'mysql') {
+            $this->markTestSkipped('Test requires a MySQL connection.');
+        }
+
+        Grammar::macro('typeBit', function () {
+            return 'bit';
+        });
+
+        Schema::create('test', function (Blueprint $table) {
+            $table->addColumn('bit', 'test_column');
+        });
+
+        Schema::table('test', function (Blueprint $table) {
+            $table->renameColumn('test_column', 'renamed_column');
+        });
+
+        $this->assertFalse(Schema::hasColumn('test', 'test_column'));
+        $this->assertTrue(Schema::hasColumn('test', 'renamed_column'));
+    }
+}
+
+class PostgresXmlType extends Type
+{
+    public function getSQLDeclaration(array $fieldDeclaration, AbstractPlatform $platform)
+    {
+        return 'xml';
+    }
+
+    public function getName()
+    {
+        return 'xml';
+    }
+}
+
+class MySQLBitType extends Type
+{
+    public function getSQLDeclaration(array $fieldDeclaration, AbstractPlatform $platform)
+    {
+        return 'bit';
+    }
+
+    public function getName()
+    {
+        return 'bit';
+    }
+}

tests/Integration/Database/DBAL/TimestampTypeTest.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace Illuminate\Tests\Integration\Database\DBAL;
+
+use Illuminate\Database\DBAL\TimestampType;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+use Illuminate\Tests\Integration\Database\DatabaseTestCase;
+
+class TimestampTypeTest extends DatabaseTestCase
+{
+    protected function defineEnvironment($app)
+    {
+        $app['config']['database.dbal.types'] = [
+            'timestamp' => TimestampType::class,
+        ];
+    }
+
+    public function testRegisterTimestampTypeOnConnection()
+    {
+        $this->assertTrue(
+            $this->app['db']->connection()
+                ->getDoctrineSchemaManager()
+                ->getDatabasePlatform()
+                ->hasDoctrineTypeMappingFor('timestamp')
+        );
+    }
+
+    public function testChangeDatetimeColumnToTimestampColumn()
+    {
+        Schema::create('test', function (Blueprint $table) {
+            $table->addColumn('datetime', 'datetime_to_timestamp');
+        });
+
+        Schema::table('test', function (Blueprint $table) {
+            $table->timestamp('datetime_to_timestamp')->nullable(true)->change();
+        });
+
+        $this->assertTrue(Schema::hasColumn('test', 'datetime_to_timestamp'));
+        // Only Postgres and MySQL actually have a timestamp type
+        in_array($this->driver, ['pgsql', 'mysql'])
+            ? $this->assertSame('timestamp', Schema::getColumnType('test', 'datetime_to_timestamp'))
+            : $this->assertSame('datetime', Schema::getColumnType('test', 'datetime_to_timestamp'));
+    }
+
+    public function testChangeTimestampColumnToDatetimeColumn()
+    {
+        Schema::create('test', function (Blueprint $table) {
+            $table->addColumn('timestamp', 'timestamp_to_datetime');
+        });
+
+        Schema::table('test', function (Blueprint $table) {
+            $table->dateTime('timestamp_to_datetime')->nullable(true)->change();
+        });
+
+        $this->assertTrue(Schema::hasColumn('test', 'timestamp_to_datetime'));
+        // Postgres only has a timestamp type
+        $this->driver === 'pgsql'
+            ? $this->assertSame('timestamp', Schema::getColumnType('test', 'timestamp_to_datetime'))
+            : $this->assertSame('datetime', Schema::getColumnType('test', 'timestamp_to_datetime'));
+    }
+}

tests/Integration/Database/SchemaBuilderTest.php

@@ -65,4 +65,26 @@ public function testRegisterCustomDoctrineType()
         $this->assertArrayHasKey(TinyInteger::NAME, Type::getTypesMap());
         $this->assertSame('tinyinteger', Schema::getColumnType('test', 'test_column'));
     }
+
+    public function testRegisterCustomDoctrineTypeASecondTime()
+    {
+        if ($this->driver !== 'sqlite') {
+            $this->markTestSkipped('Test requires a SQLite connection.');
+        }
+
+        Schema::registerCustomDoctrineType(TinyInteger::class, TinyInteger::NAME, 'TINYINT');
+
+        Schema::create('test', function (Blueprint $table) {
+            $table->string('test_column');
+        });
+
+        $blueprint = new Blueprint('test', function (Blueprint $table) {
+            $table->tinyInteger('test_column')->change();
+        });
+
+        $blueprint->build($this->getConnection(), new SQLiteGrammar);
+
+        $this->assertArrayHasKey(TinyInteger::NAME, Type::getTypesMap());
+        $this->assertSame('tinyinteger', Schema::getColumnType('test', 'test_column'));
+    }
 }