Allow to opt-out of foreign key name comparison (fixes doctrine#6518)

src/Configuration.php

@@ -64,6 +64,14 @@ class Configuration
      */
     private bool $disableTypeComments = false;
 
+    /**
+     * Whether changes in the foreign key names should lead to a schema change.
+     * If you opt-out of this, you need to handle name changes of foreign keys yourself.
+     * Databases created based on the current schema might have different foreign key names
+     * than those migrated from older schemas if you turn this off.
+     */
+    private bool $compareForeignKeyNames = true;
+
     private ?SchemaManagerFactory $schemaManagerFactory = null;
 
     public function __construct()
@@ -262,4 +270,14 @@ public function setDisableTypeComments(bool $disableTypeComments): self
 
         return $this;
     }
+
+    public function getCompareForeignKeyNames(): bool
+    {
+        return $this->compareForeignKeyNames;
+    }
+
+    public function setCompareForeignKeyNames(bool $compareForeignKeyNames): void
+    {
+        $this->compareForeignKeyNames = $compareForeignKeyNames;
+    }
 }

src/Connection.php

@@ -211,6 +211,7 @@ public function __construct(
             $this->platform = $params['platform'];
             $this->platform->setEventManager($this->_eventManager);
             $this->platform->setDisableTypeComments($config->getDisableTypeComments());
+            $this->platform->setCompareForeignKeyNames($config->getCompareForeignKeyNames());
         }
 
         $this->_expr = $this->createExpressionBuilder();
@@ -318,6 +319,7 @@ public function getDatabasePlatform()
             $this->platform = $this->detectDatabasePlatform();
             $this->platform->setEventManager($this->_eventManager);
             $this->platform->setDisableTypeComments($this->_config->getDisableTypeComments());
+            $this->platform->setCompareForeignKeyNames($this->_config->getCompareForeignKeyNames());
         }
 
         return $this->platform;

src/Platforms/AbstractPlatform.php

@@ -107,12 +107,26 @@ abstract class AbstractPlatform
 
     private bool $disableTypeComments = false;
 
+    private bool $compareForeignKeyNames = true;
+
     /** @internal */
     final public function setDisableTypeComments(bool $value): void
     {
         $this->disableTypeComments = $value;
     }
 
+    /** @internal */
+    final public function setCompareForeignKeyNames(bool $compare): void
+    {
+        $this->compareForeignKeyNames = $compare;
+    }
+
+    /** @internal */
+    public function getCompareForeignKeyNames(): bool
+    {
+        return $this->compareForeignKeyNames;
+    }
+
     /**
      * Sets the EventManager used by the Platform.
      *

src/Schema/Comparator.php

@@ -555,7 +555,10 @@ private function detectRenamedIndexes(array &$addedIndexes, array &$removedIndex
      */
     public function diffForeignKey(ForeignKeyConstraint $key1, ForeignKeyConstraint $key2)
     {
-        if (strtolower($key1->getName()) !== strtolower($key2->getName())) {
+        if (
+            (!$this->platform || $this->platform->getCompareForeignKeyNames())
+            && strtolower($key1->getName()) !== strtolower($key2->getName())
+        ) {
             return true;
         }
 

tests/Schema/AbstractComparatorTestCase.php

@@ -2,6 +2,7 @@
 
 namespace Doctrine\DBAL\Tests\Schema;
 
+use Doctrine\DBAL\Platforms\AbstractPlatform;
 use Doctrine\DBAL\Schema\Column;
 use Doctrine\DBAL\Schema\ColumnDiff;
 use Doctrine\DBAL\Schema\Comparator;
@@ -686,15 +687,25 @@ public function testDetectForeignKeyNameChange(): void
         $fkA->setLocalTable($tableA);
         $fkB = new ForeignKeyConstraint(['id'], 'bar', ['id'], 'bar_constraint');
         $fkB->setLocalTable($tableB);
-        $tableDiff = new TableDiff(
-            tableName: 'foo',
-            fromTable: $tableA,
-            addedForeignKeys: [$fkB],
-            removedForeignKeys: [$fkA],
-        );
+        $tableDiff = new TableDiff('foo', [], [], [], [], [], [], $tableA, [$fkB], [], [$fkA]);
         self::assertEquals($tableDiff, $this->comparator->compareTables($tableA, $tableB));
     }
 
+    public function testCompareForeignKeyNameChangeDisabled(): void
+    {
+        $fk1 = new ForeignKeyConstraint(['foo'], 'bar', ['baz'], 'fk1');
+        $fk2 = new ForeignKeyConstraint(['foo'], 'bar', ['baz'], 'fk2');
+
+        //Not disabled:
+        self::assertTrue($this->comparator->diffForeignKey($fk1, $fk2));
+
+        //Disabled foreign key name comparison:
+        $platform = $this->createMock(AbstractPlatform::class);
+        $platform->method('getCompareForeignKeyNames')->willReturn(false);
+        $comparatorDisabledFkName = new Comparator($platform);
+        self::assertFalse($comparatorDisabledFkName->diffForeignKey($fk1, $fk2));
+    }
+
     public function testCompareForeignKeyRestrictNoActionAreTheSame(): void
     {
         $fk1 = new ForeignKeyConstraint(['foo'], 'bar', ['baz'], 'fk1', ['onDelete' => 'NO ACTION']);