minor #61582 [DoctrineBridge] Use a single table in isSameDatabaseChecker (GromNaN)

nicolas-grekas · nicolas-grekas · commit d052b75a21d4 · 2025-09-03T17:36:38.000+02:00
This PR was squashed before being merged into the 7.4 branch. Discussion ---------- [DoctrineBridge] Use a single table in isSameDatabaseChecker | Q | A | ------------- | --- | Branch? | 7.4 | Bug fix? | yes | New feature? | yes | Deprecations? | no | Issues | Fix #54348 | License | MIT The `isSameDatabaseChecker` feature of the SchemaListener detect if 2 DBAL connections are connected to the same server and database by creating a temporary table with one connection and checking if the table exists using the other connection. Creating a temporary table with a random name cause an issue to configure permissions, as an exhaustive list of table names can be required. I propose to modify the implementation to always use the same table name, but insert a row with a random key with one connection and try to delete it with the other connection. The table is dropped only if it is empty, to prevent concurrence issues. Commits ------- e2cc570 [DoctrineBridge] Use a single table in isSameDatabaseChecker
diff --git a/src/Symfony/Bridge/Doctrine/CHANGELOG.md b/src/Symfony/Bridge/Doctrine/CHANGELOG.md
@@ -5,6 +5,7 @@ CHANGELOG
 ---
 
  * Deprecate `UniqueEntity::getRequiredOptions()` and `UniqueEntity::getDefaultOption()`
+ * Use a single table named `_schema_subscriber_check` in schema listeners to detect same database connections
 
 7.3
 ---
diff --git a/src/Symfony/Bridge/Doctrine/SchemaListener/AbstractSchemaListener.php b/src/Symfony/Bridge/Doctrine/SchemaListener/AbstractSchemaListener.php
@@ -12,8 +12,9 @@
 namespace Symfony\Bridge\Doctrine\SchemaListener;
 
 use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Exception\ConnectionException;
+use Doctrine\DBAL\Exception\DatabaseObjectExistsException;
 use Doctrine\DBAL\Exception\DatabaseObjectNotFoundException;
-use Doctrine\DBAL\Exception\TableNotFoundException;
 use Doctrine\DBAL\Schema\Name\Identifier;
 use Doctrine\DBAL\Schema\Name\UnqualifiedName;
 use Doctrine\DBAL\Schema\PrimaryKeyConstraint;
@@ -29,32 +30,47 @@ protected function getIsSameDatabaseChecker(Connection $connection): \Closure
     {
         return static function (\Closure $exec) use ($connection): bool {
             $schemaManager = method_exists($connection, 'createSchemaManager') ? $connection->createSchemaManager() : $connection->getSchemaManager();
-            $checkTable = 'schema_subscriber_check_'.bin2hex(random_bytes(7));
-            $table = new Table($checkTable);
+            $key = bin2hex(random_bytes(7));
+            $table = new Table('_schema_subscriber_check');
             $table->addColumn('id', Types::INTEGER)
                 ->setAutoincrement(true)
                 ->setNotnull(true);
+            $table->addColumn('key', Types::STRING)
+                ->setLength(14)
+                ->setNotNull(true)
+            ;
 
             if (class_exists(PrimaryKeyConstraint::class)) {
                 $table->addPrimaryKeyConstraint(new PrimaryKeyConstraint(null, [new UnqualifiedName(Identifier::unquoted('id'))], true));
             } else {
                 $table->setPrimaryKey(['id']);
             }
 
-            $schemaManager->createTable($table);
+            try {
+                $schemaManager->createTable($table);
+            } catch (DatabaseObjectExistsException) {
+            }
+
+            $connection->executeStatement('INSERT INTO _schema_subscriber_check (key) VALUES (:key)', ['key' => $key], ['key' => Types::STRING]);
 
             try {
-                $exec(\sprintf('DROP TABLE %s', $checkTable));
-            } catch (\Exception) {
-                // ignore
+                $exec('DELETE FROM _schema_subscriber_check WHERE key == :key', ['key' => $key], ['key' => Types::STRING]);
+            } catch (DatabaseObjectNotFoundException|ConnectionException) {
             }
 
             try {
-                $schemaManager->dropTable($checkTable);
+                $rowCount = $connection->executeStatement('DELETE FROM _schema_subscriber_check WHERE key == :key', ['key' => $key], ['key' => Types::STRING]);
+
+                return 0 === $rowCount;
+            } finally {
+                [$count] = $connection->executeQuery('SELECT count(id) FROM _schema_subscriber_check')->fetchOne();
 
-                return false;
-            } catch (DatabaseObjectNotFoundException) {
-                return true;
+                if (!$count) {
+                    try {
+                        $schemaManager->dropTable('_schema_subscriber_check');
+                    } catch (DatabaseObjectNotFoundException) {
+                    }
+                }
             }
         };
     }
diff --git a/src/Symfony/Bridge/Doctrine/Tests/SchemaListener/AbstractSchemaListenerTest.php b/src/Symfony/Bridge/Doctrine/Tests/SchemaListener/AbstractSchemaListenerTest.php
@@ -0,0 +1,53 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace SchemaListener;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\DriverManager;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
+use PHPUnit\Framework\TestCase;
+use Symfony\Bridge\Doctrine\SchemaListener\AbstractSchemaListener;
+
+#[RequiresPhpExtension('pdo_sqlite')]
+class AbstractSchemaListenerTest extends TestCase
+{
+    public function testSameDatabaseChecker()
+    {
+        $connectionParams = [
+            'dbname' => ':memory:',
+            'driver' => 'pdo_sqlite',
+        ];
+        // Create two distinct in-memory SQLite databases
+        $connection1 = DriverManager::getConnection($connectionParams);
+        $connection2 = DriverManager::getConnection($connectionParams);
+
+        self::assertTrue($this->getIsSameDatabaseChecker($connection1)($connection1->executeStatement(...)));
+        self::assertFalse($this->getIsSameDatabaseChecker($connection1)($connection2->executeStatement(...)));
+
+        $remainingTables = $connection1->executeQuery('SELECT name FROM sqlite_schema WHERE name <> "sqlite_sequence"')->fetchFirstColumn();
+        self::assertSame([], $remainingTables, 'Temporary table was dropped');
+    }
+
+    private function getIsSameDatabaseChecker(Connection $connection): \Closure
+    {
+        return (new class extends AbstractSchemaListener {
+            public function postGenerateSchema($event): void
+            {
+            }
+
+            public function getIsSameDatabaseChecker(Connection $connection): \Closure
+            {
+                return parent::getIsSameDatabaseChecker($connection);
+            }
+        })->getIsSameDatabaseChecker($connection);
+    }
+}
