Report the objects backing constraints

Introspection describes what the database has. A table with a primary
key or a unique constraint has a unique index over its columns, so the
per-platform predicates that withheld it are gone. The comparator
expects each such index, so reporting it does not turn a round trip from
the database towards the declared schema into a difference.

Author: morozov

UPGRADE.md

@@ -8,6 +8,11 @@ awareness about deprecated code.
 
 # Upgrade to 5.0
 
+## BC BREAK: Introspection reports the indexes backing constraints
+
+`AbstractSchemaManager::introspectTableIndexes()` now returns the indexes the database created to enforce a table's
+primary key and unique constraints.
+
 ## BC BREAK: No index is created for a foreign key constraint
 
 Declaring a foreign key constraint no longer adds an index over its referencing columns. MySQL and MariaDB create one
@@ -18,11 +23,6 @@ themselves; on the other platforms, an application that wants such an index must
 `Comparator::compareTables()` now compares unique constraints, and raises
 `Doctrine\DBAL\Schema\Exception\UnspecifiedConstraintName` when one that has to be dropped carries no name.
 
-## BC BREAK: `MetadataProvider` requires unique constraint introspection
-
-`Doctrine\DBAL\Schema\Metadata\MetadataProvider` now declares `getUniqueConstraintColumnsForAllTables()` and
-`getUniqueConstraintColumnsForTable()`. Implementations must provide them.
-
 ## BC BREAK: Added `AbstractPlatform::createDerivedObjectProvider()`
 
 `Doctrine\DBAL\Platforms\AbstractPlatform` now declares `createDerivedObjectProvider()`. Platforms extending it must
@@ -302,10 +302,8 @@ The following conflicting index configurations are no longer allowed:
 
 ## BC BREAK: Changes in features related to primary key constraints
 
-1. The `Index` class can no longer represent a primary key constraint. As a result:
-    1. The `Table::getIndexes()` and `AbstractSchemaManager::listTableIndexes()` methods no longer return the index that  
-       backs the primary key constraint.
-    2. The index that backs the primary key constraint is no longer considered during implicit index management.
+1. The `Index` class can no longer represent a primary key constraint. The index that backs one is still reported as an
+   ordinary index by `Table::getIndexes()` and `AbstractSchemaManager::introspectTableIndexes()`.
 2. The `Table::getPrimaryKey()` and `Table::setPrimaryKey()` methods have been removed.
 3. The `Table::renameIndex()` method can no longer be used to rename a primary key constraint.
 4. The `AbstractPlatform::getCreatePrimaryKeySQL()` method has been removed.

src/Platforms/Db2/Db2MetadataProvider.php

@@ -125,7 +125,6 @@ private function getTableColumns(?string $tableName): iterable
                               AND T.TABNAME = C.TABNAME
             WHERE %s
               AND T.TYPE = 'T'
-              AND I.UNIQUERULE != 'P'
             ORDER BY C.TABNAME,
                      C.COLNO
             SQL,

src/Platforms/MySQL/MySQLMetadataProvider.php

@@ -409,7 +409,6 @@ private function getIndexColumns(?string $tableName): iterable
                    SUB_PART
             FROM information_schema.STATISTICS
             WHERE %s
-              AND INDEX_NAME != 'PRIMARY'
             ORDER BY TABLE_NAME,
                 INDEX_NAME,
                 SEQ_IN_INDEX

src/Platforms/Oracle/OracleMetadataProvider.php

@@ -297,7 +297,6 @@ private function getIndexColumns(?string $tableName): iterable
                      JOIN USER_IND_COLUMNS IC
                           ON IC.INDEX_NAME = I.INDEX_NAME
             WHERE %s
-              AND (C.CONSTRAINT_TYPE IS NULL OR C.CONSTRAINT_TYPE != 'P')
             ORDER BY I.TABLE_NAME,
                      I.INDEX_NAME,
                      IC.COLUMN_POSITION

src/Platforms/PostgreSQL/PostgreSQLMetadataProvider.php

@@ -383,7 +383,6 @@ private function getIndexColumns(?string $schemaName, ?string $tableName): itera
                           ON a.attrelid = c.oid
                               AND a.attnum = keys.attnum
             WHERE %s
-              AND i.indisprimary = false
             ORDER BY n.nspname,
                      c.relname,
                      ic.relname,

src/Platforms/SQLServer/SQLServerMetadataProvider.php

@@ -328,7 +328,6 @@ private function getIndexColumns(?string $schemaName, ?string $tableName): itera
                           ON idxcol.object_id = c.object_id
                               AND idxcol.column_id = c.column_id
             WHERE %s
-              AND i.is_primary_key = 0
             ORDER BY s.name,
                      t.name,
                      i.name,

src/Platforms/SQLite/SQLiteMetadataProvider.php

@@ -323,7 +323,6 @@ private function getIndexColumns(?string $tableName): iterable
                      JOIN pragma_index_list(t.name) i
                      JOIN pragma_index_info(i.name) c
             WHERE %s
-              AND i.name NOT LIKE 'sqlite_%%'
             ORDER BY t.name,
                      i.name,
                      c.seqno

tests/Functional/Schema/AlterTableTest.php

@@ -502,7 +502,7 @@ public function testDropColumnCoveredByForeignKey(): void
         $introspected = $schemaManager->introspectTable($desired->getObjectName());
 
         self::assertTrue(
-            $comparator->compareTables($desired, $introspected)->isEmpty(),
+            $comparator->compareTables($introspected, $desired)->isEmpty(),
         );
     }
 
@@ -582,25 +582,24 @@ private function testMigration(Table $oldTable, callable $migration): void
 
         $schemaManager = $this->connection->createSchemaManager();
 
-        $oldTable = $schemaManager->introspectTable($oldTable->getObjectName());
-
         $editor = $oldTable->edit();
 
         $migration($editor);
 
         $newTable = $editor->create();
 
         $diff = $schemaManager->createComparator()
-            ->compareTables($oldTable, $newTable);
+            ->compareTables($schemaManager->introspectTable($oldTable->getObjectName()), $newTable);
 
         self::assertFalse($diff->isEmpty());
 
         $schemaManager->alterTable($diff);
 
-        $introspectedTable = $schemaManager->introspectTable($newTable->getObjectName());
-
         $diff = $schemaManager->createComparator()
-            ->compareTables($newTable, $introspectedTable);
+            ->compareTables(
+                $schemaManager->introspectTable($newTable->getObjectName()),
+                $newTable,
+            );
 
         self::assertTrue($diff->isEmpty());
     }

tests/Functional/Schema/MySQL/ComparatorTest.php

@@ -11,6 +11,11 @@
 use Doctrine\DBAL\Schema\Column;
 use Doctrine\DBAL\Schema\ColumnEditor;
 use Doctrine\DBAL\Schema\Comparator;
+use Doctrine\DBAL\Schema\ForeignKeyConstraint;
+use Doctrine\DBAL\Schema\Index;
+use Doctrine\DBAL\Schema\Index\IndexedColumn;
+use Doctrine\DBAL\Schema\Name\UnqualifiedName;
+use Doctrine\DBAL\Schema\PrimaryKeyConstraint;
 use Doctrine\DBAL\Schema\Table;
 use Doctrine\DBAL\Tests\Functional\Schema\ComparatorTestUtils;
 use Doctrine\DBAL\Tests\FunctionalTestCase;
@@ -66,6 +71,103 @@ public function testLobLengthIncrementOverLimit(string $type, int $length): void
         ComparatorTestUtils::assertDiffNotEmpty($this->connection, $this->comparator, $table);
     }
 
+    /**
+     * A column indexed by a prefix of its value cannot serve a foreign key, so MySQL indexes the
+     * referencing columns itself even though the declared index leads with them.
+     *
+     * @link https://dev.mysql.com/doc/refman/8.4/en/create-table-foreign-keys.html
+     *
+     * @throws Exception
+     */
+    public function testForeignKeyIsIndexedDespiteAnIndexPrefixingItsLastColumn(): void
+    {
+        $table = $this->createTableWithAForeignKeyIndexedByAPrefix();
+
+        $introspected = $this->schemaManager->introspectTable($table->getObjectName());
+
+        self::assertIndexedColumnListEquals(
+            [
+                new IndexedColumn(UnqualifiedName::unquoted('parent_id'), null),
+                new IndexedColumn(UnqualifiedName::unquoted('parent_code'), null),
+            ],
+            $introspected->getIndex('prefix_fk')->getIndexedColumns(),
+        );
+    }
+
+    /** @throws Exception */
+    public function testTheIndexMySQLAddsForSuchAForeignKeyIsNoDifference(): void
+    {
+        $table = $this->createTableWithAForeignKeyIndexedByAPrefix();
+
+        self::assertTrue(ComparatorTestUtils::diffFromActualToDesiredTable(
+            $this->schemaManager,
+            $this->comparator,
+            $table,
+        )->isEmpty());
+    }
+
+    /** @throws Exception */
+    private function createTableWithAForeignKeyIndexedByAPrefix(): Table
+    {
+        $this->dropTableIfExists('prefix_child');
+        $this->dropTableIfExists('prefix_parent');
+
+        $this->schemaManager->createTable(
+            Table::editor()
+                ->setUnquotedName('prefix_parent')
+                ->setColumns($this->intColumn('id'), $this->stringColumn('code'))
+                ->setPrimaryKeyConstraint(
+                    PrimaryKeyConstraint::editor()
+                        ->setUnquotedColumnNames('id', 'code')
+                        ->create(),
+                )
+                ->create(),
+        );
+
+        $table = Table::editor()
+            ->setUnquotedName('prefix_child')
+            ->setColumns($this->intColumn('parent_id'), $this->stringColumn('parent_code'))
+            ->setIndexes(
+                Index::editor()
+                    ->setUnquotedName('prefix_idx')
+                    ->addUnquotedColumnName('parent_id')
+                    ->addUnquotedColumnName('parent_code', 10)
+                    ->create(),
+            )
+            ->setForeignKeyConstraints(
+                ForeignKeyConstraint::editor()
+                    ->setUnquotedName('prefix_fk')
+                    ->setUnquotedReferencingColumnNames('parent_id', 'parent_code')
+                    ->setUnquotedReferencedTableName('prefix_parent')
+                    ->setUnquotedReferencedColumnNames('id', 'code')
+                    ->create(),
+            )
+            ->create();
+
+        $this->schemaManager->createTable($table);
+
+        return $table;
+    }
+
+    /** @param non-empty-string $name */
+    private function intColumn(string $name): Column
+    {
+        return Column::editor()
+            ->setUnquotedName($name)
+            ->setTypeName(Types::INTEGER)
+            ->create();
+    }
+
+    /** @param non-empty-string $name */
+    private function stringColumn(string $name): Column
+    {
+        return Column::editor()
+            ->setUnquotedName($name)
+            ->setTypeName(Types::STRING)
+            ->setLength(64)
+            ->create();
+    }
+
     /** @return iterable<array{string,int}> */
     public static function lobColumnProvider(): iterable
     {

tests/Functional/Schema/SchemaManagerFunctionalTestCase.php

@@ -499,17 +499,10 @@ public function testListTableIndexes(): void
 
         $this->dropAndCreateTable($table);
 
-        $this->assertIndexListEquals([
-            Index::editor()
-                ->setUnquotedName('test_index_name')
-                ->setUnquotedColumnNames('test')
-                ->setType(IndexType::UNIQUE)
-                ->create(),
-            Index::editor()
-                ->setUnquotedName('test_composite_idx')
-                ->setUnquotedColumnNames('id', 'test')
-                ->create(),
-        ], $this->schemaManager->introspectTableIndexesByUnquotedName('list_table_indexes_test'));
+        $this->assertIndexListContainsAll(
+            $table->getIndexes(),
+            $this->schemaManager->introspectTableIndexesByUnquotedName('list_table_indexes_test'),
+        );
     }
 
     public function testDropAndCreateIndex(): void
@@ -540,13 +533,10 @@ public function testDropAndCreateIndex(): void
             $table->getObjectName()->toSQL($platform),
         );
 
-        $this->assertIndexListEquals([
-            Index::editor()
-                ->setUnquotedName('test')
-                ->setUnquotedColumnNames('test')
-                ->setType(IndexType::UNIQUE)
-                ->create(),
-        ], $this->schemaManager->introspectTableIndexesByUnquotedName('test_create_index'));
+        $this->assertIndexListContainsAll(
+            $table->getIndexes(),
+            $this->schemaManager->introspectTableIndexesByUnquotedName('test_create_index'),
+        );
     }
 
     public function testDropAndCreateUniqueConstraint(): void
@@ -677,8 +667,6 @@ public function testAlterTableScenario(): void
         self::assertTrue($table->hasColumn('test'));
         self::assertTrue($table->hasColumn('foreign_key_test'));
         self::assertCount(0, $table->getForeignKeys());
-        self::assertCount(0, $table->getIndexes());
-
         $newTable = $table->edit()
             ->addColumn(
                 Column::editor()
@@ -713,9 +701,6 @@ public function testAlterTableScenario(): void
         $this->schemaManager->alterTable($diff);
 
         $table = $this->schemaManager->introspectTableByUnquotedName('alter_table');
-        self::assertCount(1, $table->getIndexes());
-        self::assertTrue($table->hasIndex('foo_idx'));
-
         $this->assertIndexEquals(
             Index::editor()
                 ->setUnquotedName('foo_idx')
@@ -739,9 +724,6 @@ public function testAlterTableScenario(): void
         $this->schemaManager->alterTable($diff);
 
         $table = $this->schemaManager->introspectTableByUnquotedName('alter_table');
-        self::assertCount(1, $table->getIndexes());
-        self::assertTrue($table->hasIndex('foo_idx'));
-
         $this->assertIndexEquals($fooIndex, $table->getIndex('foo_idx'));
 
         $barIndex = Index::editor()
@@ -759,11 +741,8 @@ public function testAlterTableScenario(): void
         $this->schemaManager->alterTable($diff);
 
         $table = $this->schemaManager->introspectTableByUnquotedName('alter_table');
-        self::assertCount(1, $table->getIndexes());
-        self::assertTrue($table->hasIndex('bar_idx'));
-        self::assertFalse($table->hasIndex('foo_idx'));
-
         $this->assertIndexEquals($barIndex, $table->getIndex('bar_idx'));
+        self::assertFalse($table->hasIndex('foo_idx'));
 
         $newTable = $table->edit()
             ->dropIndexByUnquotedName('bar_idx')
@@ -782,7 +761,6 @@ public function testAlterTableScenario(): void
 
         $table = $this->schemaManager->introspectTableByUnquotedName('alter_table');
 
-        // don't check for index size here, some platforms automatically add indexes for foreign keys.
         self::assertFalse($table->hasIndex('bar_idx'));
 
         /** @var list<ForeignKeyConstraint> $fks */
@@ -1891,12 +1869,13 @@ public function testQuotedIdentifiers(): void
             $artists->getColumn('"Name"')->getObjectName(),
         );
 
-        $this->assertIndexListEquals([
+        $this->assertIndexEquals(
             Index::editor()
                 ->setQuotedName('Idx_Artist_Name')
                 ->setQuotedColumnNames('Name')
                 ->create(),
-        ], $artists->getIndexes());
+            $artists->getIndex('"Idx_Artist_Name"'),
+        );
 
         $primaryKey = $artists->getPrimaryKeyConstraint();
         self::assertNotNull($primaryKey);