diff --git a/.php-cs-fixer.dist.php b/.php-cs-fixer.dist.php
index 167c414e3..11f81a781 100644
--- a/.php-cs-fixer.dist.php
+++ b/.php-cs-fixer.dist.php
@@ -2,7 +2,7 @@
 
 $finder = PhpCsFixer\Finder::create()
     ->in([__DIR__])
-    ->exclude(['vendor']);
+    ->exclude(['vendor', 'src/Persistence/Sql/Sqlite/debug-attach']);
 
 return (new PhpCsFixer\Config())
     ->setRiskyAllowed(true)
diff --git a/bootstrap-types.php b/bootstrap-types.php
index ccfe548c6..1a51100ac 100644
--- a/bootstrap-types.php
+++ b/bootstrap-types.php
@@ -11,6 +11,9 @@
 use Doctrine\DBAL\Schema\SqliteSchemaManager;
 use Doctrine\DBAL\Types as DbalTypes;
 
+require_once __DIR__ . '/src/Persistence/Sql/Sqlite/debug-attach/SqliteSchemaManager.php';
+require_once __DIR__ . '/src/Persistence/Sql/Sqlite/debug-attach/SqlitePlatform.php';
+
 // force SQLitePlatform and SQLiteSchemaManager classes load as in DBAL 3.x they are named with a different case
 // remove once DBAL 3.x support is dropped
 new \ReflectionClass(SqlitePlatform::class);
diff --git a/phpstan.neon.dist b/phpstan.neon.dist
index ef37669c7..c6cd0db65 100644
--- a/phpstan.neon.dist
+++ b/phpstan.neon.dist
@@ -7,6 +7,7 @@ parameters:
         - .
     excludePaths:
         - vendor
+        - src/Persistence/Sql/Sqlite/debug-attach
 
     checkMissingOverrideMethodAttribute: true
 
diff --git a/src/Persistence/Sql/Sqlite/PlatformTrait.php b/src/Persistence/Sql/Sqlite/PlatformTrait.php
index 41d37eaa2..5e5c00d03 100644
--- a/src/Persistence/Sql/Sqlite/PlatformTrait.php
+++ b/src/Persistence/Sql/Sqlite/PlatformTrait.php
@@ -9,6 +9,13 @@
 
 trait PlatformTrait
 {
+    use PlatformTraitBackport5517 {
+        PlatformTraitBackport5517::getListTableConstraintsSQL as private __getListTableConstraintsSQL;
+        PlatformTraitBackport5517::getListTableColumnsSQL as private __getListTableColumnsSQL;
+        PlatformTraitBackport5517::getListTableIndexesSQL as private __getListTableIndexesSQL;
+        PlatformTraitBackport5517::getListTableForeignKeysSQL as private __getListTableForeignKeysSQL;
+    }
+
     public function __construct()
     {
         $this->disableSchemaEmulation(); // @phpstan-ignore-line
@@ -20,6 +27,46 @@ public function getIdentifierQuoteCharacter(): string
         return '`';
     }
 
+    public function supportsForeignKeyConstraints(): bool
+    {
+        // backport https://github.com/doctrine/dbal/pull/5427, remove once DBAL 3.3.x support is dropped
+        return true;
+    }
+
+    protected function getPreAlterTableIndexForeignKeySQL(TableDiff $diff): array
+    {
+        // https://github.com/doctrine/dbal/pull/5486
+        return [];
+    }
+
+    // fix quoted table name support
+    // TODO submit a PR with fixed SQLitePlatform to DBAL
+
+    private function unquoteTableIdentifier(string $tableName): string
+    {
+        return (new Identifier($tableName))->getName();
+    }
+
+    public function getListTableConstraintsSQL($table)
+    {
+        return $this->__getListTableConstraintsSQL($this->unquoteTableIdentifier($table));
+    }
+
+    public function getListTableColumnsSQL($table, $database = null)
+    {
+        return $this->__getListTableColumnsSQL($this->unquoteTableIdentifier($table), $database);
+    }
+
+    public function getListTableIndexesSQL($table, $database = null)
+    {
+        return $this->__getListTableIndexesSQL($this->unquoteTableIdentifier($table), $database);
+    }
+
+    public function getListTableForeignKeysSQL($table, $database = null)
+    {
+        return $this->__getListTableForeignKeysSQL($this->unquoteTableIdentifier($table), $database);
+    }
+
     #[\Override]
     public function getAlterTableSQL(TableDiff $diff): array
     {
diff --git a/src/Persistence/Sql/Sqlite/PlatformTraitBackport5517.php b/src/Persistence/Sql/Sqlite/PlatformTraitBackport5517.php
new file mode 100644
index 000000000..f4b27b0c1
--- /dev/null
+++ b/src/Persistence/Sql/Sqlite/PlatformTraitBackport5517.php
@@ -0,0 +1,123 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Atk4\Data\Persistence\Sql\Sqlite;
+
+use Doctrine\DBAL\Schema\ForeignKeyConstraint;
+use Doctrine\DBAL\Schema\Identifier;
+
+/**
+ * Drop once https://github.com/doctrine/dbal/pull/5517 is merged and DBAL 3.3.x support is removed.
+ */
+trait PlatformTraitBackport5517
+{
+    private function emulateSchemaNamespacing(string $tableName): string
+    {
+        return $tableName;
+    }
+
+    public function getForeignKeyDeclarationSQL(ForeignKeyConstraint $foreignKey)
+    {
+        return parent::getForeignKeyDeclarationSQL(new ForeignKeyConstraint(
+            $foreignKey->getQuotedLocalColumns($this),
+            $this->emulateSchemaNamespacing($foreignKey->getQuotedForeignTableName($this)),
+            $foreignKey->getQuotedForeignColumns($this),
+            $foreignKey->getName(),
+            $foreignKey->getOptions()
+        ));
+    }
+
+    protected function _getCreateTableSQL($name, array $columns, array $options = [])
+    {
+        $name = $this->emulateSchemaNamespacing($name);
+        $queryFields = $this->getColumnDeclarationListSQL($columns);
+
+        if (isset($options['uniqueConstraints']) && !empty($options['uniqueConstraints'])) {
+            foreach ($options['uniqueConstraints'] as $constraintName => $definition) {
+                $queryFields .= ', ' . $this->getUniqueConstraintDeclarationSQL($constraintName, $definition);
+            }
+        }
+
+        $queryFields .= \Closure::bind(fn () => $this->getNonAutoincrementPrimaryKeyDefinition($columns, $options), $this, parent::class)();
+
+        if (isset($options['foreignKeys'])) {
+            foreach ($options['foreignKeys'] as $foreignKey) {
+                $queryFields .= ', ' . $this->getForeignKeyDeclarationSQL($foreignKey);
+            }
+        }
+
+        $tableComment = '';
+        if (isset($options['comment'])) {
+            $comment = trim($options['comment'], " '");
+
+            $tableComment = \Closure::bind(fn () => $this->getInlineTableCommentSQL($comment), $this, parent::class)();
+        }
+
+        $query = ['CREATE TABLE ' . $name . ' ' . $tableComment . '(' . $queryFields . ')'];
+
+        if (isset($options['alter']) && $options['alter'] === true) {
+            return $query;
+        }
+
+        if (isset($options['indexes']) && !empty($options['indexes'])) {
+            foreach ($options['indexes'] as $indexDef) {
+                $query[] = $this->getCreateIndexSQL($indexDef, $name);
+            }
+        }
+
+        if (isset($options['unique']) && !empty($options['unique'])) {
+            foreach ($options['unique'] as $indexDef) {
+                $query[] = $this->getCreateIndexSQL($indexDef, $name);
+            }
+        }
+
+        return $query;
+    }
+
+    public function getListTableConstraintsSQL($table)
+    {
+        $table = $this->emulateSchemaNamespacing($table);
+
+        return sprintf(
+            "SELECT sql FROM sqlite_master WHERE type='index' AND tbl_name = %s AND sql NOT NULL ORDER BY name",
+            $this->quoteStringLiteral($table)
+        );
+    }
+
+    public function getListTableColumnsSQL($table, $database = null)
+    {
+        $table = $this->emulateSchemaNamespacing($table);
+
+        return sprintf('PRAGMA table_info(%s)', $this->quoteStringLiteral($table));
+    }
+
+    public function getListTableIndexesSQL($table, $database = null)
+    {
+        $table = $this->emulateSchemaNamespacing($table);
+
+        return sprintf('PRAGMA index_list(%s)', $this->quoteStringLiteral($table));
+    }
+
+    public function getTruncateTableSQL($tableName, $cascade = false)
+    {
+        $tableIdentifier = new Identifier($tableName);
+        $tableName = $this->emulateSchemaNamespacing($tableIdentifier->getQuotedName($this));
+
+        return 'DELETE FROM ' . $tableName;
+    }
+
+    public function getTemporaryTableName($tableName)
+    {
+        $tableName = $this->emulateSchemaNamespacing($tableName);
+
+        return $tableName;
+    }
+
+    public function getListTableForeignKeysSQL($table, $database = null)
+    {
+        $table = $this->emulateSchemaNamespacing($table);
+
+        return sprintf('PRAGMA foreign_key_list(%s)', $this->quoteStringLiteral($table));
+    }
+}
diff --git a/src/Persistence/Sql/Sqlite/debug-attach/SqlitePlatform.php b/src/Persistence/Sql/Sqlite/debug-attach/SqlitePlatform.php
new file mode 100644
index 000000000..e707c9162
--- /dev/null
+++ b/src/Persistence/Sql/Sqlite/debug-attach/SqlitePlatform.php
@@ -0,0 +1,1502 @@
+<?php
+
+// copied from https://github.com/doctrine/dbal/blob/3.6.7/src/Platforms/SqlitePlatform.php
+
+namespace Doctrine\DBAL\Platforms;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Driver\API\SQLite\UserDefinedFunctions;
+use Doctrine\DBAL\Exception;
+use Doctrine\DBAL\Schema\Column;
+use Doctrine\DBAL\Schema\Constraint;
+use Doctrine\DBAL\Schema\ForeignKeyConstraint;
+use Doctrine\DBAL\Schema\Identifier;
+use Doctrine\DBAL\Schema\Index;
+use Doctrine\DBAL\Schema\SchemaException;
+use Doctrine\DBAL\Schema\SqliteSchemaManager;
+use Doctrine\DBAL\Schema\Table;
+use Doctrine\DBAL\Schema\TableDiff;
+use Doctrine\DBAL\TransactionIsolationLevel;
+use Doctrine\DBAL\Types;
+use Doctrine\DBAL\Types\IntegerType;
+use Doctrine\Deprecations\Deprecation;
+
+use function array_combine;
+use function array_keys;
+use function array_merge;
+use function array_search;
+use function array_unique;
+use function array_values;
+use function count;
+use function implode;
+use function is_numeric;
+use function sprintf;
+use function sqrt;
+use function str_replace;
+use function strlen;
+use function strtolower;
+use function trim;
+
+/**
+ * The SqlitePlatform class describes the specifics and dialects of the SQLite
+ * database platform.
+ *
+ * @todo   Rename: SQLitePlatform
+ */
+class SqlitePlatform extends AbstractPlatform
+{
+    private bool $schemaEmulationEnabled = true;
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getRegexpExpression()
+    {
+        return 'REGEXP';
+    }
+
+    /**
+     * @deprecated Generate dates within the application.
+     *
+     * @param string $type
+     *
+     * @return string
+     */
+    public function getNowExpression($type = 'timestamp')
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/pull/4753',
+            'SqlitePlatform::getNowExpression() is deprecated. Generate dates within the application.',
+        );
+
+        switch ($type) {
+            case 'time':
+                return 'time(\'now\')';
+
+            case 'date':
+                return 'date(\'now\')';
+
+            case 'timestamp':
+            default:
+                return 'datetime(\'now\')';
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getModExpression($expression1, $expression2)
+    {
+        return $expression1 . ' % ' . $expression2;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getTrimExpression($str, $mode = TrimMode::UNSPECIFIED, $char = false)
+    {
+        $trimChar = $char !== false ? ', ' . $char : '';
+
+        switch ($mode) {
+            case TrimMode::LEADING:
+                $trimFn = 'LTRIM';
+                break;
+
+            case TrimMode::TRAILING:
+                $trimFn = 'RTRIM';
+                break;
+
+            default:
+                $trimFn = 'TRIM';
+        }
+
+        return $trimFn . '(' . $str . $trimChar . ')';
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * SQLite only supports the 2 parameter variant of this function
+     */
+    public function getSubstringExpression($string, $start, $length = null)
+    {
+        if ($length !== null) {
+            return 'SUBSTR(' . $string . ', ' . $start . ', ' . $length . ')';
+        }
+
+        return 'SUBSTR(' . $string . ', ' . $start . ', LENGTH(' . $string . '))';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getLocateExpression($str, $substr, $startPos = false)
+    {
+        if ($startPos === false || $startPos === 1 || $startPos === '1') {
+            return 'INSTR(' . $str . ', ' . $substr . ')';
+        }
+
+        return 'CASE WHEN INSTR(SUBSTR(' . $str . ', ' . $startPos . '), ' . $substr
+            . ') > 0 THEN INSTR(SUBSTR(' . $str . ', ' . $startPos . '), ' . $substr . ') + ' . $startPos
+            . ' - 1 ELSE 0 END';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getDateArithmeticIntervalExpression($date, $operator, $interval, $unit)
+    {
+        switch ($unit) {
+            case DateIntervalUnit::SECOND:
+            case DateIntervalUnit::MINUTE:
+            case DateIntervalUnit::HOUR:
+                return 'DATETIME(' . $date . ",'" . $operator . $interval . ' ' . $unit . "')";
+        }
+
+        switch ($unit) {
+            case DateIntervalUnit::WEEK:
+                $interval *= 7;
+                $unit      = DateIntervalUnit::DAY;
+                break;
+
+            case DateIntervalUnit::QUARTER:
+                $interval *= 3;
+                $unit      = DateIntervalUnit::MONTH;
+                break;
+        }
+
+        if (! is_numeric($interval)) {
+            $interval = "' || " . $interval . " || '";
+        }
+
+        return 'DATE(' . $date . ",'" . $operator . $interval . ' ' . $unit . "')";
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getDateDiffExpression($date1, $date2)
+    {
+        return sprintf("JULIANDAY(%s, 'start of day') - JULIANDAY(%s, 'start of day')", $date1, $date2);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The DBAL doesn't support databases on the SQLite platform. The expression here always returns a fixed string
+     * as an indicator of an implicitly selected database.
+     *
+     * @link https://www.sqlite.org/lang_select.html
+     * @see Connection::getDatabase()
+     */
+    public function getCurrentDatabaseExpression(): string
+    {
+        return "'main'";
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function _getTransactionIsolationLevelSQL($level)
+    {
+        switch ($level) {
+            case TransactionIsolationLevel::READ_UNCOMMITTED:
+                return '0';
+
+            case TransactionIsolationLevel::READ_COMMITTED:
+            case TransactionIsolationLevel::REPEATABLE_READ:
+            case TransactionIsolationLevel::SERIALIZABLE:
+                return '1';
+
+            default:
+                return parent::_getTransactionIsolationLevelSQL($level);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getSetTransactionIsolationSQL($level)
+    {
+        return 'PRAGMA read_uncommitted = ' . $this->_getTransactionIsolationLevelSQL($level);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @deprecated
+     */
+    public function prefersIdentityColumns()
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/pull/1519',
+            'SqlitePlatform::prefersIdentityColumns() is deprecated.',
+        );
+
+        return true;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getBooleanTypeDeclarationSQL(array $column)
+    {
+        return 'BOOLEAN';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getIntegerTypeDeclarationSQL(array $column)
+    {
+        return 'INTEGER' . $this->_getCommonIntegerTypeDeclarationSQL($column);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getBigIntTypeDeclarationSQL(array $column)
+    {
+        // SQLite autoincrement is implicit for INTEGER PKs, but not for BIGINT columns
+        if (! empty($column['autoincrement'])) {
+            return $this->getIntegerTypeDeclarationSQL($column);
+        }
+
+        return 'BIGINT' . $this->_getCommonIntegerTypeDeclarationSQL($column);
+    }
+
+    /**
+     * @deprecated Use {@see getSmallIntTypeDeclarationSQL()} instead.
+     *
+     * @param array<string, mixed> $column
+     *
+     * @return string
+     */
+    public function getTinyIntTypeDeclarationSQL(array $column)
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/pull/5511',
+            '%s is deprecated. Use getSmallIntTypeDeclarationSQL() instead.',
+            __METHOD__,
+        );
+
+        // SQLite autoincrement is implicit for INTEGER PKs, but not for TINYINT columns
+        if (! empty($column['autoincrement'])) {
+            return $this->getIntegerTypeDeclarationSQL($column);
+        }
+
+        return 'TINYINT' . $this->_getCommonIntegerTypeDeclarationSQL($column);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getSmallIntTypeDeclarationSQL(array $column)
+    {
+        // SQLite autoincrement is implicit for INTEGER PKs, but not for SMALLINT columns
+        if (! empty($column['autoincrement'])) {
+            return $this->getIntegerTypeDeclarationSQL($column);
+        }
+
+        return 'SMALLINT' . $this->_getCommonIntegerTypeDeclarationSQL($column);
+    }
+
+    /**
+     * @deprecated Use {@see getIntegerTypeDeclarationSQL()} instead.
+     *
+     * @param array<string, mixed> $column
+     *
+     * @return string
+     */
+    public function getMediumIntTypeDeclarationSQL(array $column)
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/pull/5511',
+            '%s is deprecated. Use getIntegerTypeDeclarationSQL() instead.',
+            __METHOD__,
+        );
+
+        // SQLite autoincrement is implicit for INTEGER PKs, but not for MEDIUMINT columns
+        if (! empty($column['autoincrement'])) {
+            return $this->getIntegerTypeDeclarationSQL($column);
+        }
+
+        return 'MEDIUMINT' . $this->_getCommonIntegerTypeDeclarationSQL($column);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getDateTimeTypeDeclarationSQL(array $column)
+    {
+        return 'DATETIME';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getDateTypeDeclarationSQL(array $column)
+    {
+        return 'DATE';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getTimeTypeDeclarationSQL(array $column)
+    {
+        return 'TIME';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function _getCommonIntegerTypeDeclarationSQL(array $column)
+    {
+        // sqlite autoincrement is only possible for the primary key
+        if (! empty($column['autoincrement'])) {
+            return ' PRIMARY KEY AUTOINCREMENT';
+        }
+
+        return ! empty($column['unsigned']) ? ' UNSIGNED' : '';
+    }
+
+    /**
+     * Disables schema emulation.
+     *
+     * Schema emulation is enabled by default to maintain backwards compatibility.
+     * Disable it to opt-in to the behavior of DBAL 4.
+     *
+     * @deprecated Will be removed in DBAL 4.0.
+     */
+    public function disableSchemaEmulation(): void
+    {
+        $this->schemaEmulationEnabled = false;
+    }
+
+    private function emulateSchemaNamespacing(string $tableName): string
+    {
+        return $this->schemaEmulationEnabled
+            ? str_replace('.', '__', $tableName)
+            : $tableName;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @internal The method should be only used from within the {@see AbstractPlatform} class hierarchy.
+     */
+    public function getForeignKeyDeclarationSQL(ForeignKeyConstraint $foreignKey)
+    {
+        return parent::getForeignKeyDeclarationSQL(new ForeignKeyConstraint(
+            $foreignKey->getQuotedLocalColumns($this),
+            $this->emulateSchemaNamespacing($foreignKey->getQuotedForeignTableName($this)),
+            $foreignKey->getQuotedForeignColumns($this),
+            $foreignKey->getName(),
+            $foreignKey->getOptions(),
+        ));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function _getCreateTableSQL($name, array $columns, array $options = [])
+    {
+        $name        = $this->emulateSchemaNamespacing($name);
+        $queryFields = $this->getColumnDeclarationListSQL($columns);
+
+        if (isset($options['uniqueConstraints']) && ! empty($options['uniqueConstraints'])) {
+            foreach ($options['uniqueConstraints'] as $constraintName => $definition) {
+                $queryFields .= ', ' . $this->getUniqueConstraintDeclarationSQL($constraintName, $definition);
+            }
+        }
+
+        $queryFields .= $this->getNonAutoincrementPrimaryKeyDefinition($columns, $options);
+
+        if (isset($options['foreignKeys'])) {
+            foreach ($options['foreignKeys'] as $foreignKey) {
+                $queryFields .= ', ' . $this->getForeignKeyDeclarationSQL($foreignKey);
+            }
+        }
+
+        $tableComment = '';
+        if (isset($options['comment'])) {
+            $comment = trim($options['comment'], " '");
+
+            $tableComment = $this->getInlineTableCommentSQL($comment);
+        }
+
+        $query = ['CREATE TABLE ' . $name . ' ' . $tableComment . '(' . $queryFields . ')'];
+
+        if (isset($options['alter']) && $options['alter'] === true) {
+            return $query;
+        }
+
+        if (isset($options['indexes']) && ! empty($options['indexes'])) {
+            foreach ($options['indexes'] as $indexDef) {
+                $query[] = $this->getCreateIndexSQL($indexDef, $name);
+            }
+        }
+
+        if (isset($options['unique']) && ! empty($options['unique'])) {
+            foreach ($options['unique'] as $indexDef) {
+                $query[] = $this->getCreateIndexSQL($indexDef, $name);
+            }
+        }
+
+        return $query;
+    }
+
+    /**
+     * Generate a PRIMARY KEY definition if no autoincrement value is used
+     *
+     * @param mixed[][] $columns
+     * @param mixed[]   $options
+     */
+    private function getNonAutoincrementPrimaryKeyDefinition(array $columns, array $options): string
+    {
+        if (empty($options['primary'])) {
+            return '';
+        }
+
+        $keyColumns = array_unique(array_values($options['primary']));
+
+        foreach ($keyColumns as $keyColumn) {
+            if (! empty($columns[$keyColumn]['autoincrement'])) {
+                return '';
+            }
+        }
+
+        return ', PRIMARY KEY(' . implode(', ', $keyColumns) . ')';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getVarcharTypeDeclarationSQLSnippet($length, $fixed)
+    {
+        return $fixed ? ($length > 0 ? 'CHAR(' . $length . ')' : 'CHAR(255)')
+            : ($length > 0 ? 'VARCHAR(' . $length . ')' : 'TEXT');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getBinaryTypeDeclarationSQLSnippet($length, $fixed)
+    {
+        return 'BLOB';
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @deprecated
+     */
+    public function getBinaryMaxLength()
+    {
+        Deprecation::triggerIfCalledFromOutside(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/issues/3263',
+            'SqlitePlatform::getBinaryMaxLength() is deprecated.',
+        );
+
+        return 0;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @deprecated
+     */
+    public function getBinaryDefaultLength()
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/issues/3263',
+            'Relying on the default binary column length is deprecated, specify the length explicitly.',
+        );
+
+        return 0;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getClobTypeDeclarationSQL(array $column)
+    {
+        return 'CLOB';
+    }
+
+    /**
+     * @deprecated
+     *
+     * {@inheritDoc}
+     */
+    public function getListTableConstraintsSQL($table)
+    {
+        $table = $this->emulateSchemaNamespacing($table);
+
+        return sprintf(
+            "SELECT sql FROM sqlite_master WHERE type='index' AND tbl_name = %s AND sql NOT NULL ORDER BY name",
+            $this->quoteStringLiteral($table),
+        );
+    }
+
+    /**
+     * @deprecated The SQL used for schema introspection is an implementation detail and should not be relied upon.
+     *
+     * {@inheritDoc}
+     */
+    public function getListTableColumnsSQL($table, $database = null)
+    {
+        $table = $this->emulateSchemaNamespacing($table);
+
+        return sprintf('PRAGMA table_info(%s)', $this->quoteStringLiteral($table));
+    }
+
+    /**
+     * @deprecated The SQL used for schema introspection is an implementation detail and should not be relied upon.
+     *
+     * {@inheritDoc}
+     */
+    public function getListTableIndexesSQL($table, $database = null)
+    {
+        $table = $this->emulateSchemaNamespacing($table);
+
+        return sprintf('PRAGMA index_list(%s)', $this->quoteStringLiteral($table));
+    }
+
+    /**
+     * @deprecated The SQL used for schema introspection is an implementation detail and should not be relied upon.
+     *
+     * {@inheritDoc}
+     */
+    public function getListTablesSQL()
+    {
+        return 'SELECT name FROM sqlite_master'
+            . " WHERE type = 'table'"
+            . " AND name != 'sqlite_sequence'"
+            . " AND name != 'geometry_columns'"
+            . " AND name != 'spatial_ref_sys'"
+            . ' UNION ALL SELECT name FROM sqlite_temp_master'
+            . " WHERE type = 'table' ORDER BY name";
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @internal The method should be only used from within the {@see AbstractSchemaManager} class hierarchy.
+     */
+    public function getListViewsSQL($database)
+    {
+        return "SELECT name, sql FROM sqlite_master WHERE type='view' AND sql NOT NULL";
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @internal The method should be only used from within the {@see AbstractPlatform} class hierarchy.
+     */
+    public function getAdvancedForeignKeyOptionsSQL(ForeignKeyConstraint $foreignKey)
+    {
+        $query = parent::getAdvancedForeignKeyOptionsSQL($foreignKey);
+
+        if (! $foreignKey->hasOption('deferrable') || $foreignKey->getOption('deferrable') === false) {
+            $query .= ' NOT';
+        }
+
+        $query .= ' DEFERRABLE';
+        $query .= ' INITIALLY';
+
+        if ($foreignKey->hasOption('deferred') && $foreignKey->getOption('deferred') !== false) {
+            $query .= ' DEFERRED';
+        } else {
+            $query .= ' IMMEDIATE';
+        }
+
+        return $query;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @deprecated
+     */
+    public function supportsCreateDropDatabase()
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/pull/5513',
+            '%s is deprecated.',
+            __METHOD__,
+        );
+
+        return false;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function supportsIdentityColumns()
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @internal The method should be only used from within the {@see AbstractPlatform} class hierarchy.
+     */
+    public function supportsColumnCollation()
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @internal The method should be only used from within the {@see AbstractPlatform} class hierarchy.
+     */
+    public function supportsInlineColumnComments()
+    {
+        return true;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getName()
+    {
+        Deprecation::triggerIfCalledFromOutside(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/issues/4749',
+            'SqlitePlatform::getName() is deprecated. Identify platforms by their class.',
+        );
+
+        return 'sqlite';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getTruncateTableSQL($tableName, $cascade = false)
+    {
+        $tableIdentifier = new Identifier($tableName);
+        $tableName       = $this->emulateSchemaNamespacing($tableIdentifier->getQuotedName($this));
+
+        return 'DELETE FROM ' . $tableName;
+    }
+
+    /**
+     * User-defined function for Sqlite that is used with PDO::sqliteCreateFunction().
+     *
+     * @deprecated The driver will use {@see sqrt()} in the next major release.
+     *
+     * @param int|float $value
+     *
+     * @return float
+     */
+    public static function udfSqrt($value)
+    {
+        return sqrt($value);
+    }
+
+    /**
+     * User-defined function for Sqlite that implements MOD(a, b).
+     *
+     * @deprecated The driver will use {@see UserDefinedFunctions::mod()} in the next major release.
+     *
+     * @param int $a
+     * @param int $b
+     *
+     * @return int
+     */
+    public static function udfMod($a, $b)
+    {
+        return UserDefinedFunctions::mod($a, $b);
+    }
+
+    /**
+     * @deprecated The driver will use {@see UserDefinedFunctions::locate()} in the next major release.
+     *
+     * @param string $str
+     * @param string $substr
+     * @param int    $offset
+     *
+     * @return int
+     */
+    public static function udfLocate($str, $substr, $offset = 0)
+    {
+        return UserDefinedFunctions::locate($str, $substr, $offset);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getForUpdateSQL()
+    {
+        return '';
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @internal The method should be only used from within the {@see AbstractPlatform} class hierarchy.
+     */
+    public function getInlineColumnCommentSQL($comment)
+    {
+        return '--' . str_replace("\n", "\n--", $comment) . "\n";
+    }
+
+    private function getInlineTableCommentSQL(string $comment): string
+    {
+        return $this->getInlineColumnCommentSQL($comment);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function initializeDoctrineTypeMappings()
+    {
+        $this->doctrineTypeMapping = [
+            'bigint'           => 'bigint',
+            'bigserial'        => 'bigint',
+            'blob'             => 'blob',
+            'boolean'          => 'boolean',
+            'char'             => 'string',
+            'clob'             => 'text',
+            'date'             => 'date',
+            'datetime'         => 'datetime',
+            'decimal'          => 'decimal',
+            'double'           => 'float',
+            'double precision' => 'float',
+            'float'            => 'float',
+            'image'            => 'string',
+            'int'              => 'integer',
+            'integer'          => 'integer',
+            'longtext'         => 'text',
+            'longvarchar'      => 'string',
+            'mediumint'        => 'integer',
+            'mediumtext'       => 'text',
+            'ntext'            => 'string',
+            'numeric'          => 'decimal',
+            'nvarchar'         => 'string',
+            'real'             => 'float',
+            'serial'           => 'integer',
+            'smallint'         => 'smallint',
+            'text'             => 'text',
+            'time'             => 'time',
+            'timestamp'        => 'datetime',
+            'tinyint'          => 'boolean',
+            'tinytext'         => 'text',
+            'varchar'          => 'string',
+            'varchar2'         => 'string',
+        ];
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @deprecated Implement {@see createReservedKeywordsList()} instead.
+     */
+    protected function getReservedKeywordsClass()
+    {
+        Deprecation::triggerIfCalledFromOutside(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/issues/4510',
+            'SqlitePlatform::getReservedKeywordsClass() is deprecated,'
+                . ' use SqlitePlatform::createReservedKeywordsList() instead.',
+        );
+
+        return Keywords\SQLiteKeywords::class;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getPreAlterTableIndexForeignKeySQL(TableDiff $diff)
+    {
+        return [];
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getPostAlterTableIndexForeignKeySQL(TableDiff $diff)
+    {
+        $table = $diff->getOldTable();
+
+        if (! $table instanceof Table) {
+            throw new Exception(
+                'Sqlite platform requires for alter table the table diff with reference to original table schema',
+            );
+        }
+
+        $sql       = [];
+        $tableName = $diff->getNewName();
+
+        if ($tableName === false) {
+            $tableName = $diff->getName($this);
+        }
+
+        foreach ($this->getIndexesInAlteredTable($diff, $table) as $index) {
+            if ($index->isPrimary()) {
+                continue;
+            }
+
+            $sql[] = $this->getCreateIndexSQL($index, $tableName->getQuotedName($this));
+        }
+
+        return $sql;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function doModifyLimitQuery($query, $limit, $offset)
+    {
+        if ($limit === null && $offset > 0) {
+            return sprintf('%s LIMIT -1 OFFSET %d', $query, $offset);
+        }
+
+        return parent::doModifyLimitQuery($query, $limit, $offset);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getBlobTypeDeclarationSQL(array $column)
+    {
+        return 'BLOB';
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getTemporaryTableName($tableName)
+    {
+        $tableName = $this->emulateSchemaNamespacing($tableName);
+
+        return $tableName;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @deprecated
+     *
+     * Sqlite Platform emulates schema by underscoring each dot and generating tables
+     * into the default database.
+     *
+     * This hack is implemented to be able to use SQLite as testdriver when
+     * using schema supporting databases.
+     */
+    public function canEmulateSchemas()
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/pull/4805',
+            'SqlitePlatform::canEmulateSchemas() is deprecated.',
+        );
+
+        return $this->schemaEmulationEnabled;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getCreateTablesSQL(array $tables): array
+    {
+        $sql = [];
+
+        foreach ($tables as $table) {
+            $sql = array_merge($sql, $this->getCreateTableSQL($table));
+        }
+
+        return $sql;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getDropTablesSQL(array $tables): array
+    {
+        $sql = [];
+
+        foreach ($tables as $table) {
+            $sql[] = $this->getDropTableSQL($table->getQuotedName($this));
+        }
+
+        return $sql;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getCreatePrimaryKeySQL(Index $index, $table)
+    {
+        throw new Exception('Sqlite platform does not support alter primary key.');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getCreateForeignKeySQL(ForeignKeyConstraint $foreignKey, $table)
+    {
+        throw new Exception('Sqlite platform does not support alter foreign key.');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getDropForeignKeySQL($foreignKey, $table)
+    {
+        throw new Exception('Sqlite platform does not support alter foreign key.');
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @deprecated
+     */
+    public function getCreateConstraintSQL(Constraint $constraint, $table)
+    {
+        throw new Exception('Sqlite platform does not support alter constraint.');
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @param int|null $createFlags
+     * @psalm-param int-mask-of<AbstractPlatform::CREATE_*>|null $createFlags
+     */
+    public function getCreateTableSQL(Table $table, $createFlags = null)
+    {
+        $createFlags = $createFlags ?? self::CREATE_INDEXES | self::CREATE_FOREIGNKEYS;
+
+        return parent::getCreateTableSQL($table, $createFlags);
+    }
+
+    /**
+     * @deprecated The SQL used for schema introspection is an implementation detail and should not be relied upon.
+     *
+     * @param string      $table
+     * @param string|null $database
+     *
+     * @return string
+     */
+    public function getListTableForeignKeysSQL($table, $database = null)
+    {
+        $table = $this->emulateSchemaNamespacing($table);
+
+        return sprintf('PRAGMA foreign_key_list(%s)', $this->quoteStringLiteral($table));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getAlterTableSQL(TableDiff $diff)
+    {
+        $sql = $this->getSimpleAlterTableSQL($diff);
+        if ($sql !== false) {
+            return $sql;
+        }
+
+        $table = $diff->getOldTable();
+
+        if (! $table instanceof Table) {
+            throw new Exception(
+                'Sqlite platform requires for alter table the table diff with reference to original table schema',
+            );
+        }
+
+        $columns        = [];
+        $oldColumnNames = [];
+        $newColumnNames = [];
+        $columnSql      = [];
+
+        foreach ($table->getColumns() as $columnName => $column) {
+            $columnName                  = strtolower($columnName);
+            $columns[$columnName]        = $column;
+            $oldColumnNames[$columnName] = $newColumnNames[$columnName] = $column->getQuotedName($this);
+        }
+
+        foreach ($diff->getDroppedColumns() as $column) {
+            if ($this->onSchemaAlterTableRemoveColumn($column, $diff, $columnSql)) {
+                continue;
+            }
+
+            $columnName = strtolower($column->getName());
+            if (! isset($columns[$columnName])) {
+                continue;
+            }
+
+            unset(
+                $columns[$columnName],
+                $oldColumnNames[$columnName],
+                $newColumnNames[$columnName],
+            );
+        }
+
+        foreach ($diff->getRenamedColumns() as $oldColumnName => $column) {
+            if ($this->onSchemaAlterTableRenameColumn($oldColumnName, $column, $diff, $columnSql)) {
+                continue;
+            }
+
+            $oldColumnName = strtolower($oldColumnName);
+
+            $columns = $this->replaceColumn(
+                $table->getName(),
+                $columns,
+                $oldColumnName,
+                $column,
+            );
+
+            if (! isset($newColumnNames[$oldColumnName])) {
+                continue;
+            }
+
+            $newColumnNames[$oldColumnName] = $column->getQuotedName($this);
+        }
+
+        foreach ($diff->getModifiedColumns() as $columnDiff) {
+            if ($this->onSchemaAlterTableChangeColumn($columnDiff, $diff, $columnSql)) {
+                continue;
+            }
+
+            $oldColumn = $columnDiff->getOldColumn() ?? $columnDiff->getOldColumnName();
+
+            $oldColumnName = strtolower($oldColumn->getName());
+
+            $columns = $this->replaceColumn(
+                $table->getName(),
+                $columns,
+                $oldColumnName,
+                $columnDiff->getNewColumn(),
+            );
+
+            if (! isset($newColumnNames[$oldColumnName])) {
+                continue;
+            }
+
+            $newColumnNames[$oldColumnName] = $columnDiff->getNewColumn()->getQuotedName($this);
+        }
+
+        foreach ($diff->getAddedColumns() as $column) {
+            if ($this->onSchemaAlterTableAddColumn($column, $diff, $columnSql)) {
+                continue;
+            }
+
+            $columns[strtolower($column->getName())] = $column;
+        }
+
+        $sql      = [];
+        $tableSql = [];
+        if (! $this->onSchemaAlterTable($diff, $tableSql)) {
+            if (str_contains($table->getName(), '.')) {
+                $nameArr = explode('.', $table->getName(), 2);
+                $dataTable = new Table(/* $nameArr[0] . '.' . */ '__temp__' . $nameArr[1]);
+            } else {
+                $dataTable = new Table('__temp__' . $table->getName());
+            }
+
+            $newTable = new Table(
+                $table->getQuotedName($this),
+                $columns,
+                $this->getPrimaryIndexInAlteredTable($diff, $table),
+                [],
+                $this->getForeignKeysInAlteredTable($diff, $table),
+                $table->getOptions(),
+            );
+            $newTable->addOption('alter', true);
+
+            $sql = $this->getPreAlterTableIndexForeignKeySQL($diff);
+
+            $sql[] = sprintf(
+                'CREATE TEMPORARY TABLE %s AS SELECT %s FROM %s',
+                $dataTable->getQuotedName($this),
+                implode(', ', $oldColumnNames),
+                $table->getQuotedName($this),
+            );
+            $sql[] = $this->getDropTableSQL($table);
+
+            $sql   = array_merge($sql, $this->getCreateTableSQL($newTable));
+            $sql[] = sprintf(
+                'INSERT INTO %s (%s) SELECT %s FROM %s',
+                $newTable->getQuotedName($this),
+                implode(', ', $newColumnNames),
+                implode(', ', $oldColumnNames),
+                $dataTable->getQuotedName($this),
+            );
+            $sql[] = $this->getDropTableSQL($dataTable->getQuotedName($this));
+
+            $newName = $diff->getNewName();
+
+            if ($newName !== false) {
+                Deprecation::trigger(
+                    'doctrine/dbal',
+                    'https://github.com/doctrine/dbal/pull/5663',
+                    'Generation of "rename table" SQL using %s is deprecated. Use getRenameTableSQL() instead.',
+                    __METHOD__,
+                );
+
+                $sql[] = sprintf(
+                    'ALTER TABLE %s RENAME TO %s',
+                    $newTable->getQuotedName($this),
+                    $newName->getQuotedName($this),
+                );
+            }
+
+            $sql = array_merge($sql, $this->getPostAlterTableIndexForeignKeySQL($diff));
+        }
+
+        return array_merge($sql, $tableSql, $columnSql);
+    }
+
+    /**
+     * Replace the column with the given name with the new column.
+     *
+     * @param string               $tableName
+     * @param array<string,Column> $columns
+     * @param string               $columnName
+     *
+     * @return array<string,Column>
+     *
+     * @throws Exception
+     */
+    private function replaceColumn($tableName, array $columns, $columnName, Column $column): array
+    {
+        $keys  = array_keys($columns);
+        $index = array_search($columnName, $keys, true);
+
+        if ($index === false) {
+            throw SchemaException::columnDoesNotExist($columnName, $tableName);
+        }
+
+        $values = array_values($columns);
+
+        $keys[$index]   = strtolower($column->getName());
+        $values[$index] = $column;
+
+        return array_combine($keys, $values);
+    }
+
+    /**
+     * @return string[]|false
+     *
+     * @throws Exception
+     */
+    private function getSimpleAlterTableSQL(TableDiff $diff)
+    {
+        // Suppress changes on integer type autoincrement columns.
+        foreach ($diff->getModifiedColumns() as $columnDiff) {
+            $oldColumn = $columnDiff->getOldColumn();
+
+            if ($oldColumn === null) {
+                continue;
+            }
+
+            $newColumn = $columnDiff->getNewColumn();
+
+            if (! $newColumn->getAutoincrement() || ! $newColumn->getType() instanceof IntegerType) {
+                continue;
+            }
+
+            $oldColumnName = $oldColumn->getName();
+
+            if (! $columnDiff->hasTypeChanged() && $columnDiff->hasUnsignedChanged()) {
+                unset($diff->changedColumns[$oldColumnName]);
+
+                continue;
+            }
+
+            $fromColumnType = $oldColumn->getType();
+
+            if (! ($fromColumnType instanceof Types\SmallIntType) && ! ($fromColumnType instanceof Types\BigIntType)) {
+                continue;
+            }
+
+            unset($diff->changedColumns[$oldColumnName]);
+        }
+
+        if (
+            count($diff->getModifiedColumns()) > 0
+            || count($diff->getDroppedColumns()) > 0
+            || count($diff->getRenamedColumns()) > 0
+            || count($diff->getAddedIndexes()) > 0
+            || count($diff->getModifiedIndexes()) > 0
+            || count($diff->getDroppedIndexes()) > 0
+            || count($diff->getRenamedIndexes()) > 0
+            || count($diff->getAddedForeignKeys()) > 0
+            || count($diff->getModifiedForeignKeys()) > 0
+            || count($diff->getDroppedForeignKeys()) > 0
+        ) {
+            return false;
+        }
+
+        $table = $diff->getOldTable() ?? $diff->getName($this);
+
+        $sql       = [];
+        $tableSql  = [];
+        $columnSql = [];
+
+        foreach ($diff->getAddedColumns() as $column) {
+            if ($this->onSchemaAlterTableAddColumn($column, $diff, $columnSql)) {
+                continue;
+            }
+
+            $definition = array_merge([
+                'unique' => null,
+                'autoincrement' => null,
+                'default' => null,
+            ], $column->toArray());
+
+            $type = $definition['type'];
+
+            switch (true) {
+                case isset($definition['columnDefinition']) || $definition['autoincrement'] || $definition['unique']:
+                case $type instanceof Types\DateTimeType && $definition['default'] === $this->getCurrentTimestampSQL():
+                case $type instanceof Types\DateType && $definition['default'] === $this->getCurrentDateSQL():
+                case $type instanceof Types\TimeType && $definition['default'] === $this->getCurrentTimeSQL():
+                    return false;
+            }
+
+            $definition['name'] = $column->getQuotedName($this);
+            if ($type instanceof Types\StringType) {
+                $definition['length'] ??= 255;
+            }
+
+            $sql[] = 'ALTER TABLE ' . $table->getQuotedName($this) . ' ADD COLUMN '
+                . $this->getColumnDeclarationSQL($definition['name'], $definition);
+        }
+
+        if (! $this->onSchemaAlterTable($diff, $tableSql)) {
+            if ($diff->newName !== false) {
+                Deprecation::trigger(
+                    'doctrine/dbal',
+                    'https://github.com/doctrine/dbal/pull/5663',
+                    'Generation of SQL that renames a table using %s is deprecated.'
+                        . ' Use getRenameTableSQL() instead.',
+                    __METHOD__,
+                );
+
+                $newTable = new Identifier($diff->newName);
+
+                $sql[] = 'ALTER TABLE ' . $table->getQuotedName($this) . ' RENAME TO '
+                    . $newTable->getQuotedName($this);
+            }
+        }
+
+        return array_merge($sql, $tableSql, $columnSql);
+    }
+
+    /** @return string[] */
+    private function getColumnNamesInAlteredTable(TableDiff $diff, Table $fromTable): array
+    {
+        $columns = [];
+
+        foreach ($fromTable->getColumns() as $columnName => $column) {
+            $columns[strtolower($columnName)] = $column->getName();
+        }
+
+        foreach ($diff->getDroppedColumns() as $column) {
+            $columnName = strtolower($column->getName());
+            if (! isset($columns[$columnName])) {
+                continue;
+            }
+
+            unset($columns[$columnName]);
+        }
+
+        foreach ($diff->getRenamedColumns() as $oldColumnName => $column) {
+            $columnName                          = $column->getName();
+            $columns[strtolower($oldColumnName)] = $columnName;
+            $columns[strtolower($columnName)]    = $columnName;
+        }
+
+        foreach ($diff->getModifiedColumns() as $columnDiff) {
+            $oldColumn = $columnDiff->getOldColumn() ?? $columnDiff->getOldColumnName();
+
+            $oldColumnName                       = $oldColumn->getName();
+            $newColumnName                       = $columnDiff->getNewColumn()->getName();
+            $columns[strtolower($oldColumnName)] = $newColumnName;
+            $columns[strtolower($newColumnName)] = $newColumnName;
+        }
+
+        foreach ($diff->getAddedColumns() as $column) {
+            $columnName                       = $column->getName();
+            $columns[strtolower($columnName)] = $columnName;
+        }
+
+        return $columns;
+    }
+
+    /** @return Index[] */
+    private function getIndexesInAlteredTable(TableDiff $diff, Table $fromTable): array
+    {
+        $indexes     = $fromTable->getIndexes();
+        $columnNames = $this->getColumnNamesInAlteredTable($diff, $fromTable);
+
+        foreach ($indexes as $key => $index) {
+            foreach ($diff->getRenamedIndexes() as $oldIndexName => $renamedIndex) {
+                if (strtolower($key) !== strtolower($oldIndexName)) {
+                    continue;
+                }
+
+                unset($indexes[$key]);
+            }
+
+            $changed      = false;
+            $indexColumns = [];
+            foreach ($index->getColumns() as $columnName) {
+                $normalizedColumnName = strtolower($columnName);
+                if (! isset($columnNames[$normalizedColumnName])) {
+                    unset($indexes[$key]);
+                    continue 2;
+                }
+
+                $indexColumns[] = $columnNames[$normalizedColumnName];
+                if ($columnName === $columnNames[$normalizedColumnName]) {
+                    continue;
+                }
+
+                $changed = true;
+            }
+
+            if (! $changed) {
+                continue;
+            }
+
+            $indexes[$key] = new Index(
+                $index->getName(),
+                $indexColumns,
+                $index->isUnique(),
+                $index->isPrimary(),
+                $index->getFlags(),
+            );
+        }
+
+        foreach ($diff->getDroppedIndexes() as $index) {
+            $indexName = strtolower($index->getName());
+            if (strlen($indexName) === 0 || ! isset($indexes[$indexName])) {
+                continue;
+            }
+
+            unset($indexes[$indexName]);
+        }
+
+        foreach (
+            array_merge(
+                $diff->getModifiedIndexes(),
+                $diff->getAddedIndexes(),
+                $diff->getRenamedIndexes(),
+            ) as $index
+        ) {
+            $indexName = strtolower($index->getName());
+            if (strlen($indexName) > 0) {
+                $indexes[$indexName] = $index;
+            } else {
+                $indexes[] = $index;
+            }
+        }
+
+        return $indexes;
+    }
+
+    /** @return ForeignKeyConstraint[] */
+    private function getForeignKeysInAlteredTable(TableDiff $diff, Table $fromTable): array
+    {
+        $foreignKeys = $fromTable->getForeignKeys();
+        $columnNames = $this->getColumnNamesInAlteredTable($diff, $fromTable);
+
+        foreach ($foreignKeys as $key => $constraint) {
+            $changed      = false;
+            $localColumns = [];
+            foreach ($constraint->getLocalColumns() as $columnName) {
+                $normalizedColumnName = strtolower($columnName);
+                if (! isset($columnNames[$normalizedColumnName])) {
+                    unset($foreignKeys[$key]);
+                    continue 2;
+                }
+
+                $localColumns[] = $columnNames[$normalizedColumnName];
+                if ($columnName === $columnNames[$normalizedColumnName]) {
+                    continue;
+                }
+
+                $changed = true;
+            }
+
+            if (! $changed) {
+                continue;
+            }
+
+            $foreignKeys[$key] = new ForeignKeyConstraint(
+                $localColumns,
+                $constraint->getForeignTableName(),
+                $constraint->getForeignColumns(),
+                $constraint->getName(),
+                $constraint->getOptions(),
+            );
+        }
+
+        foreach ($diff->getDroppedForeignKeys() as $constraint) {
+            if (! $constraint instanceof ForeignKeyConstraint) {
+                $constraint = new Identifier($constraint);
+            }
+
+            $constraintName = strtolower($constraint->getName());
+            if (strlen($constraintName) === 0 || ! isset($foreignKeys[$constraintName])) {
+                continue;
+            }
+
+            unset($foreignKeys[$constraintName]);
+        }
+
+        foreach (array_merge($diff->getModifiedForeignKeys(), $diff->getAddedForeignKeys()) as $constraint) {
+            $constraintName = strtolower($constraint->getName());
+            if (strlen($constraintName) > 0) {
+                $foreignKeys[$constraintName] = $constraint;
+            } else {
+                $foreignKeys[] = $constraint;
+            }
+        }
+
+        return $foreignKeys;
+    }
+
+    /** @return Index[] */
+    private function getPrimaryIndexInAlteredTable(TableDiff $diff, Table $fromTable): array
+    {
+        $primaryIndex = [];
+
+        foreach ($this->getIndexesInAlteredTable($diff, $fromTable) as $index) {
+            if (! $index->isPrimary()) {
+                continue;
+            }
+
+            $primaryIndex = [$index->getName() => $index];
+        }
+
+        return $primaryIndex;
+    }
+
+    public function createSchemaManager(Connection $connection): SqliteSchemaManager
+    {
+        return new SqliteSchemaManager($connection, $this);
+    }
+
+    public function getCreateIndexSQL(Index $index, $table)
+    {
+        $sql = parent::getCreateIndexSQL($index, $table);
+
+        // https://sqlite.org/forum/info/f8f0c1a1069bb40a
+        $sql = preg_replace('~^(CREATE\s+.*?INDEX\s+)(.+?)(\s+ON\s+)(.+?)\.(.+?)(\s+\()~', '$1$4.$2$3$5$6', $sql);
+
+        return $sql;
+    }
+}
diff --git a/src/Persistence/Sql/Sqlite/debug-attach/SqliteSchemaManager.php b/src/Persistence/Sql/Sqlite/debug-attach/SqliteSchemaManager.php
new file mode 100644
index 000000000..764a4d3f6
--- /dev/null
+++ b/src/Persistence/Sql/Sqlite/debug-attach/SqliteSchemaManager.php
@@ -0,0 +1,818 @@
+<?php
+
+// copied from https://github.com/doctrine/dbal/blob/3.6.7/src/Schema/SqliteSchemaManager.php
+
+namespace Doctrine\DBAL\Schema;
+
+use Doctrine\DBAL\DriverManager;
+use Doctrine\DBAL\Exception;
+use Doctrine\DBAL\Platforms\SQLite;
+use Doctrine\DBAL\Platforms\SqlitePlatform;
+use Doctrine\DBAL\Result;
+use Doctrine\DBAL\Types\StringType;
+use Doctrine\DBAL\Types\TextType;
+use Doctrine\DBAL\Types\Type;
+use Doctrine\Deprecations\Deprecation;
+
+use function array_change_key_case;
+use function array_map;
+use function array_merge;
+use function count;
+use function explode;
+use function file_exists;
+use function implode;
+use function preg_match;
+use function preg_match_all;
+use function preg_quote;
+use function preg_replace;
+use function rtrim;
+use function str_replace;
+use function strcasecmp;
+use function strpos;
+use function strtolower;
+use function trim;
+use function unlink;
+use function usort;
+
+use const CASE_LOWER;
+
+/**
+ * Sqlite SchemaManager.
+ *
+ * @extends AbstractSchemaManager<SqlitePlatform>
+ */
+class SqliteSchemaManager extends AbstractSchemaManager
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function listTableNames()
+    {
+        return $this->doListTableNames();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function listTables()
+    {
+        return $this->doListTables();
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @deprecated Use {@see introspectTable()} instead.
+     */
+    public function listTableDetails($name)
+    {
+        Deprecation::triggerIfCalledFromOutside(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/pull/5595',
+            '%s is deprecated. Use introspectTable() instead.',
+            __METHOD__,
+        );
+
+        return $this->doListTableDetails($name);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function listTableColumns($table, $database = null)
+    {
+        return $this->doListTableColumns($table, $database);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function listTableIndexes($table)
+    {
+        return $this->doListTableIndexes($table);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function fetchForeignKeyColumnsByTable(string $databaseName): array
+    {
+        $columnsByTable = parent::fetchForeignKeyColumnsByTable($databaseName);
+
+        if (count($columnsByTable) > 0) {
+            foreach ($columnsByTable as $table => $columns) {
+                $columnsByTable[$table] = $this->addDetailsToTableForeignKeyColumns($table, $columns);
+            }
+        }
+
+        return $columnsByTable;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @deprecated Delete the database file using the filesystem.
+     */
+    public function dropDatabase($database)
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/issues/4963',
+            'SqliteSchemaManager::dropDatabase() is deprecated. Delete the database file using the filesystem.',
+        );
+
+        if (! file_exists($database)) {
+            return;
+        }
+
+        unlink($database);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @deprecated The engine will create the database file automatically.
+     */
+    public function createDatabase($database)
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/issues/4963',
+            'SqliteSchemaManager::createDatabase() is deprecated.'
+                . ' The engine will create the database file automatically.',
+        );
+
+        $params = $this->_conn->getParams();
+
+        $params['path'] = $database;
+        unset($params['memory']);
+
+        $conn = DriverManager::getConnection($params);
+        $conn->connect();
+        $conn->close();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function createForeignKey(ForeignKeyConstraint $foreignKey, $table)
+    {
+        if (! $table instanceof Table) {
+            $table = $this->listTableDetails($table);
+        }
+
+        $this->alterTable(new TableDiff($table->getName(), [], [], [], [], [], [], $table, [$foreignKey]));
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @deprecated Use {@see dropForeignKey()} and {@see createForeignKey()} instead.
+     */
+    public function dropAndCreateForeignKey(ForeignKeyConstraint $foreignKey, $table)
+    {
+        Deprecation::trigger(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/pull/4897',
+            'SqliteSchemaManager::dropAndCreateForeignKey() is deprecated.'
+                . ' Use SqliteSchemaManager::dropForeignKey() and SqliteSchemaManager::createForeignKey() instead.',
+        );
+
+        if (! $table instanceof Table) {
+            $table = $this->listTableDetails($table);
+        }
+
+        $this->alterTable(new TableDiff($table->getName(), [], [], [], [], [], [], $table, [], [$foreignKey]));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function dropForeignKey($foreignKey, $table)
+    {
+        if (! $table instanceof Table) {
+            $table = $this->listTableDetails($table);
+        }
+
+        $this->alterTable(new TableDiff($table->getName(), [], [], [], [], [], [], $table, [], [], [$foreignKey]));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function listTableForeignKeys($table, $database = null)
+    {
+        $table = $this->normalizeName($table);
+
+        $columns = $this->selectForeignKeyColumns($database ?? 'main', $table)
+            ->fetchAllAssociative();
+
+        if (count($columns) > 0) {
+            $columns = $this->addDetailsToTableForeignKeyColumns($table, $columns);
+        }
+
+        return $this->_getPortableTableForeignKeysList($columns);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function _getPortableTableDefinition($table)
+    {
+        return $table['table_name'];
+    }
+
+    /**
+     * @return array{?string, string}
+     */
+    public static function extractSchemaFromTableName(string $tableName, $fallbackDatabaseName = null): array
+    {
+        if (!str_contains($tableName, '.')) {
+            return [$fallbackDatabaseName, $tableName];
+        }
+
+        return explode('.', $tableName, 2);
+    }
+
+    /**
+     * @return array{?string, string}
+     */
+    public static function extractSchemaAsPrefixFromTableName(string $tableName, $fallbackDatabaseName = null): array
+    {
+        [$schemaName, $tableName] = self::extractSchemaFromTableName($tableName);
+
+        return [
+            ($schemaName ?? $fallbackDatabaseName) === null ? null : ($schemaName ?? $fallbackDatabaseName) . '.',
+            $tableName,
+        ];
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @link http://ezcomponents.org/docs/api/trunk/DatabaseSchema/ezcDbSchemaPgsqlReader.html
+     */
+    protected function _getPortableTableIndexesList($tableIndexes, $tableName = null)
+    {
+        $indexBuffer = [];
+
+        [$schemaPrefix, $tableName] = self::extractSchemaAsPrefixFromTableName($tableName);
+
+        // fetch primary
+        $indexArray = $this->_conn->fetchAllAssociative('SELECT * FROM ' . $schemaPrefix . 'PRAGMA_TABLE_INFO (?)', [$tableName]);
+
+        usort(
+            $indexArray,
+            /**
+             * @param array<string,mixed> $a
+             * @param array<string,mixed> $b
+             */
+            static function (array $a, array $b): int {
+                if ($a['pk'] === $b['pk']) {
+                    return $a['cid'] - $b['cid'];
+                }
+
+                return $a['pk'] - $b['pk'];
+            },
+        );
+
+        foreach ($indexArray as $indexColumnRow) {
+            if ($indexColumnRow['pk'] === 0 || $indexColumnRow['pk'] === '0') {
+                continue;
+            }
+
+            $indexBuffer[] = [
+                'key_name' => 'primary',
+                'primary' => true,
+                'non_unique' => false,
+                'column_name' => $indexColumnRow['name'],
+            ];
+        }
+
+        // fetch regular indexes
+        foreach ($tableIndexes as $tableIndex) {
+            // Ignore indexes with reserved names, e.g. autoindexes
+            if (strpos($tableIndex['name'], 'sqlite_') === 0) {
+                continue;
+            }
+
+            $keyName           = $tableIndex['name'];
+            $idx               = [];
+            $idx['key_name']   = $keyName;
+            $idx['primary']    = false;
+            $idx['non_unique'] = ! $tableIndex['unique'];
+
+            $indexArray = $this->_conn->fetchAllAssociative('SELECT * FROM PRAGMA_INDEX_INFO (?)', [$keyName]);
+
+            foreach ($indexArray as $indexColumnRow) {
+                $idx['column_name'] = $indexColumnRow['name'];
+                $indexBuffer[]      = $idx;
+            }
+        }
+
+        return parent::_getPortableTableIndexesList($indexBuffer, $tableName);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function _getPortableTableColumnList($table, $database, $tableColumns)
+    {
+        $list = parent::_getPortableTableColumnList($table, $database, $tableColumns);
+
+        // find column with autoincrement
+        $autoincrementColumn = null;
+        $autoincrementCount  = 0;
+
+        foreach ($tableColumns as $tableColumn) {
+            if ($tableColumn['pk'] === 0 || $tableColumn['pk'] === '0') {
+                continue;
+            }
+
+            $autoincrementCount++;
+            if ($autoincrementColumn !== null || strtolower($tableColumn['type']) !== 'integer') {
+                continue;
+            }
+
+            $autoincrementColumn = $tableColumn['name'];
+        }
+
+        if ($autoincrementCount === 1 && $autoincrementColumn !== null) {
+            foreach ($list as $column) {
+                if ($autoincrementColumn !== $column->getName()) {
+                    continue;
+                }
+
+                $column->setAutoincrement(true);
+            }
+        }
+
+        // inspect column collation and comments
+        $createSql = $this->getCreateTableSQL($table);
+
+        foreach ($list as $columnName => $column) {
+            $type = $column->getType();
+
+            if ($type instanceof StringType || $type instanceof TextType) {
+                $column->setPlatformOption(
+                    'collation',
+                    $this->parseColumnCollationFromSQL($columnName, $createSql) ?? 'BINARY',
+                );
+            }
+
+            $comment = $this->parseColumnCommentFromSQL($columnName, $createSql);
+
+            if ($comment === null) {
+                continue;
+            }
+
+            $type = $this->extractDoctrineTypeFromComment($comment, '');
+
+            if ($type !== '') {
+                $column->setType(Type::getType($type));
+
+                $comment = $this->removeDoctrineTypeFromComment($comment, $type);
+            }
+
+            $column->setComment($comment);
+        }
+
+        return $list;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function _getPortableTableColumnDefinition($tableColumn)
+    {
+        $parts               = explode('(', $tableColumn['type']);
+        $tableColumn['type'] = trim($parts[0]);
+        if (isset($parts[1])) {
+            $length                = trim($parts[1], ')');
+            $tableColumn['length'] = $length;
+        }
+
+        $dbType   = strtolower($tableColumn['type']);
+        $length   = $tableColumn['length'] ?? null;
+        $unsigned = false;
+
+        if (strpos($dbType, ' unsigned') !== false) {
+            $dbType   = str_replace(' unsigned', '', $dbType);
+            $unsigned = true;
+        }
+
+        $fixed   = false;
+        $type    = $this->_platform->getDoctrineTypeMapping($dbType);
+        $default = $tableColumn['dflt_value'];
+        if ($default === 'NULL') {
+            $default = null;
+        }
+
+        if ($default !== null) {
+            // SQLite returns the default value as a literal expression, so we need to parse it
+            if (preg_match('/^\'(.*)\'$/s', $default, $matches) === 1) {
+                $default = str_replace("''", "'", $matches[1]);
+            }
+        }
+
+        $notnull = (bool) $tableColumn['notnull'];
+
+        if (! isset($tableColumn['name'])) {
+            $tableColumn['name'] = '';
+        }
+
+        $precision = null;
+        $scale     = null;
+
+        switch ($dbType) {
+            case 'char':
+                $fixed = true;
+                break;
+            case 'float':
+            case 'double':
+            case 'real':
+            case 'decimal':
+            case 'numeric':
+                if (isset($tableColumn['length'])) {
+                    if (strpos($tableColumn['length'], ',') === false) {
+                        $tableColumn['length'] .= ',0';
+                    }
+
+                    [$precision, $scale] = array_map('trim', explode(',', $tableColumn['length']));
+                }
+
+                $length = null;
+                break;
+        }
+
+        $options = [
+            'length'   => $length,
+            'unsigned' => $unsigned,
+            'fixed'    => $fixed,
+            'notnull'  => $notnull,
+            'default'  => $default,
+            'precision' => $precision,
+            'scale'     => $scale,
+            'autoincrement' => false,
+        ];
+
+        return new Column($tableColumn['name'], Type::getType($type), $options);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function _getPortableViewDefinition($view)
+    {
+        return new View($view['name'], $view['sql']);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function _getPortableTableForeignKeysList($tableForeignKeys)
+    {
+        $list = [];
+        foreach ($tableForeignKeys as $value) {
+            $value = array_change_key_case($value, CASE_LOWER);
+            $id    = $value['id'];
+            if (! isset($list[$id])) {
+                if (! isset($value['on_delete']) || $value['on_delete'] === 'RESTRICT') {
+                    $value['on_delete'] = null;
+                }
+
+                if (! isset($value['on_update']) || $value['on_update'] === 'RESTRICT') {
+                    $value['on_update'] = null;
+                }
+
+                $list[$id] = [
+                    'name' => $value['constraint_name'],
+                    'local' => [],
+                    'foreign' => [],
+                    'foreignTable' => $value['table'],
+                    'onDelete' => $value['on_delete'],
+                    'onUpdate' => $value['on_update'],
+                    'deferrable' => $value['deferrable'],
+                    'deferred' => $value['deferred'],
+                ];
+            }
+
+            $list[$id]['local'][] = $value['from'];
+
+            if ($value['to'] === null) {
+                continue;
+            }
+
+            $list[$id]['foreign'][] = $value['to'];
+        }
+
+        return parent::_getPortableTableForeignKeysList($list);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function _getPortableTableForeignKeyDefinition($tableForeignKey): ForeignKeyConstraint
+    {
+        return new ForeignKeyConstraint(
+            $tableForeignKey['local'],
+            $tableForeignKey['foreignTable'],
+            $tableForeignKey['foreign'],
+            $tableForeignKey['name'],
+            [
+                'onDelete' => $tableForeignKey['onDelete'],
+                'onUpdate' => $tableForeignKey['onUpdate'],
+                'deferrable' => $tableForeignKey['deferrable'],
+                'deferred' => $tableForeignKey['deferred'],
+            ],
+        );
+    }
+
+    private function parseColumnCollationFromSQL(string $column, string $sql): ?string
+    {
+        $pattern = '{(?:\W' . preg_quote($column) . '\W|\W'
+            . preg_quote($this->_platform->quoteSingleIdentifier($column))
+            . '\W)[^,(]+(?:\([^()]+\)[^,]*)?(?:(?:DEFAULT|CHECK)\s*(?:\(.*?\))?[^,]*)*COLLATE\s+["\']?([^\s,"\')]+)}is';
+
+        if (preg_match($pattern, $sql, $match) !== 1) {
+            return null;
+        }
+
+        return $match[1];
+    }
+
+    private function parseTableCommentFromSQL(string $table, string $sql): ?string
+    {
+        $pattern = '/\s* # Allow whitespace characters at start of line
+CREATE\sTABLE # Match "CREATE TABLE"
+(?:\W"' . preg_quote($this->_platform->quoteSingleIdentifier($table), '/') . '"\W|\W' . preg_quote($table, '/')
+            . '\W) # Match table name (quoted and unquoted)
+( # Start capture
+   (?:\s*--[^\n]*\n?)+ # Capture anything that starts with whitespaces followed by -- until the end of the line(s)
+)/ix';
+
+        if (preg_match($pattern, $sql, $match) !== 1) {
+            return null;
+        }
+
+        $comment = preg_replace('{^\s*--}m', '', rtrim($match[1], "\n"));
+
+        return $comment === '' ? null : $comment;
+    }
+
+    private function parseColumnCommentFromSQL(string $column, string $sql): ?string
+    {
+        $pattern = '{[\s(,](?:\W' . preg_quote($this->_platform->quoteSingleIdentifier($column))
+            . '\W|\W' . preg_quote($column) . '\W)(?:\([^)]*?\)|[^,(])*?,?((?:(?!\n))(?:\s*--[^\n]*\n?)+)}i';
+
+        if (preg_match($pattern, $sql, $match) !== 1) {
+            return null;
+        }
+
+        $comment = preg_replace('{^\s*--}m', '', rtrim($match[1], "\n"));
+
+        return $comment === '' ? null : $comment;
+    }
+
+    /** @throws Exception */
+    private function getCreateTableSQL(string $table): string
+    {
+        [$schema, $table] = self::extractSchemaAsPrefixFromTableName($table);
+
+        $sql = $this->_conn->fetchOne(
+            '
+SELECT sql
+  FROM (
+      SELECT *
+        FROM ' . $schema . 'sqlite_master
+   UNION ALL
+      SELECT *
+        FROM temp.sqlite_master
+  )
+WHERE type = \'table\'
+AND name = ?
+'
+            ,
+            [$table],
+        );
+
+        if ($sql !== false) {
+            return $sql;
+        }
+
+        return '';
+    }
+
+    /**
+     * @param list<array<string,mixed>> $columns
+     *
+     * @return list<array<string,mixed>>
+     *
+     * @throws Exception
+     */
+    private function addDetailsToTableForeignKeyColumns(string $table, array $columns): array
+    {
+        $foreignKeyDetails = $this->getForeignKeyDetails($table);
+        $foreignKeyCount   = count($foreignKeyDetails);
+
+        foreach ($columns as $i => $column) {
+            // SQLite identifies foreign keys in reverse order of appearance in SQL
+            $columns[$i] = array_merge($column, $foreignKeyDetails[$foreignKeyCount - $column['id'] - 1]);
+        }
+
+        return $columns;
+    }
+
+    /**
+     * @param string $table
+     *
+     * @return list<array<string, mixed>>
+     *
+     * @throws Exception
+     */
+    private function getForeignKeyDetails($table)
+    {
+        $createSql = $this->getCreateTableSQL($table);
+
+        if (
+            preg_match_all(
+                '#
+                    (?:CONSTRAINT\s+(\S+)\s+)?
+                    (?:FOREIGN\s+KEY[^)]+\)\s*)?
+                    REFERENCES\s+\S+\s*(?:\([^)]+\))?
+                    (?:
+                        [^,]*?
+                        (NOT\s+DEFERRABLE|DEFERRABLE)
+                        (?:\s+INITIALLY\s+(DEFERRED|IMMEDIATE))?
+                    )?#isx',
+                $createSql,
+                $match,
+            ) === 0
+        ) {
+            return [];
+        }
+
+        $names      = $match[1];
+        $deferrable = $match[2];
+        $deferred   = $match[3];
+        $details    = [];
+
+        for ($i = 0, $count = count($match[0]); $i < $count; $i++) {
+            $details[] = [
+                'constraint_name' => isset($names[$i]) && $names[$i] !== '' ? $names[$i] : null,
+                'deferrable'      => isset($deferrable[$i]) && strcasecmp($deferrable[$i], 'deferrable') === 0,
+                'deferred'        => isset($deferred[$i]) && strcasecmp($deferred[$i], 'deferred') === 0,
+            ];
+        }
+
+        return $details;
+    }
+
+    public function createComparator(): Comparator
+    {
+        return new SQLite\Comparator($this->_platform);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @deprecated
+     */
+    public function getSchemaSearchPaths()
+    {
+        Deprecation::triggerIfCalledFromOutside(
+            'doctrine/dbal',
+            'https://github.com/doctrine/dbal/pull/4821',
+            'SqliteSchemaManager::getSchemaSearchPaths() is deprecated.',
+        );
+
+        // SQLite does not support schemas or databases
+        return [];
+    }
+
+    protected function selectTableNames(string $databaseName): Result
+    {
+        $sql = '
+SELECT name AS table_name
+FROM ' . $databaseName . '.sqlite_master
+WHERE type = \'table\'
+  AND name != \'sqlite_sequence\'
+  AND name != \'geometry_columns\'
+  AND name != \'spatial_ref_sys\'
+UNION ALL
+SELECT name
+FROM temp.sqlite_master
+WHERE type = \'table\'
+ORDER BY name
+';
+
+        return $this->_conn->executeQuery($sql);
+    }
+
+    protected function selectTableColumns(string $databaseName, ?string $tableName = null): Result
+    {
+        [$databaseName, $tableName] = self::extractSchemaAsPrefixFromTableName($tableName);
+
+        $sql = '
+            SELECT t.name AS table_name,
+                   c.*
+              FROM ' . $databaseName . 'sqlite_master t
+              JOIN pragma_table_info(t.name) c
+';
+
+        $conditions = [
+            "t.type = 'table'",
+            "t.name NOT IN ('geometry_columns', 'spatial_ref_sys', 'sqlite_sequence')",
+        ];
+        $params     = [];
+
+        if ($tableName !== null) {
+            $conditions[] = 't.name = ?';
+            $params[]     = str_replace('.', '__', $tableName);
+        }
+
+        $sql .= ' WHERE ' . implode(' AND ', $conditions) . ' ORDER BY t.name, c.cid';
+
+        return $this->_conn->executeQuery($sql, $params);
+    }
+
+    protected function selectIndexColumns(string $databaseName, ?string $tableName = null): Result
+    {
+        [$databaseName, $tableName] = self::extractSchemaAsPrefixFromTableName($tableName, $databaseName);
+
+        $sql = '
+            SELECT t.name AS table_name,
+                   i.*
+              FROM ' . $databaseName . 'sqlite_master t
+              JOIN ' . $databaseName . 'pragma_index_list(t.name) i
+';
+
+        $conditions = [
+            "t.type = 'table'",
+            "t.name NOT IN ('geometry_columns', 'spatial_ref_sys', 'sqlite_sequence')",
+        ];
+        $params     = [];
+
+        if ($tableName !== null) {
+            $conditions[] = 't.name = ?';
+            $params[]     = str_replace('.', '__', $tableName);
+        }
+
+        $sql .= ' WHERE ' . implode(' AND ', $conditions) . ' ORDER BY t.name, i.seq';
+
+        return $this->_conn->executeQuery($sql, $params);
+    }
+
+    protected function selectForeignKeyColumns(string $databaseName, ?string $tableName = null): Result
+    {
+        [$databaseName, $tableName] = self::extractSchemaAsPrefixFromTableName($tableName, $databaseName);
+
+        $sql = '
+            SELECT t.name AS table_name,
+                   p.*
+              FROM ' . $databaseName . 'sqlite_master t
+              JOIN ' . $databaseName . 'pragma_foreign_key_list(t.name) p
+                ON p."seq" != "-1"
+';
+
+        $conditions = [
+            "t.type = 'table'",
+            "t.name NOT IN ('geometry_columns', 'spatial_ref_sys', 'sqlite_sequence')",
+        ];
+        $params     = [];
+
+        if ($tableName !== null) {
+            $conditions[] = 't.name = ?';
+            $params[]     = str_replace('.', '__', $tableName);
+        }
+
+        $sql .= ' WHERE ' . implode(' AND ', $conditions) . ' ORDER BY t.name, p.id DESC, p.seq';
+
+        return $this->_conn->executeQuery($sql, $params);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function fetchTableOptionsByTable(string $databaseName, ?string $tableName = null): array
+    {
+        if ($tableName === null) {
+            $tables = $this->listTableNames();
+        } else {
+            $tables = [$tableName];
+        }
+
+        $tableOptions = [];
+        foreach ($tables as $table) {
+            $comment = $this->parseTableCommentFromSQL($table, $this->getCreateTableSQL($table));
+
+            if ($comment === null) {
+                continue;
+            }
+
+            $tableOptions[$table]['comment'] = $comment;
+        }
+
+        return $tableOptions;
+    }
+}
diff --git a/tests/RandomTest.php b/tests/RandomTest.php
index 5d09e95ad..1d6528f49 100644
--- a/tests/RandomTest.php
+++ b/tests/RandomTest.php
@@ -554,16 +554,16 @@ public function testNoWriteActionDelete(): void
     public function testTableWithSchema(): void
     {
         if ($this->getDatabasePlatform() instanceof SQLitePlatform) {
-            $userSchema = 'db1';
+            $userSchema = 'main';
             $docSchema = 'db2';
-            $runWithDb = false;
+
+            $this->getConnection()->expr('ATTACH DATABASE \':memory:\' AS {}', [$docSchema])->executeStatement();
         } else {
             $dbSchema = $this->getConnection()->dsql()
                 ->field($this->getConnection()->expr('{{}}', [$this->getDatabasePlatform()->getCurrentDatabaseExpression(true)])) // @phpstan-ignore-line
                 ->getOne();
             $userSchema = $dbSchema;
             $docSchema = $dbSchema;
-            $runWithDb = true;
         }
 
         $user = new Model($this->db, ['table' => $userSchema . '.user']);
@@ -588,29 +588,32 @@ public function testTableWithSchema(): void
             $render[0]
         );
 
-        if ($runWithDb) {
-            $this->createMigrator($user)->create();
-            $this->createMigrator($doc)->create();
+        $this->createMigrator($user)->create();
+        $this->createMigrator($doc)->create();
+        $this->debug = true;
+        if ($this->getDatabasePlatform() instanceof SQLitePlatform) {
+            $this->createMigrator()->createIndex([$doc->getField('user_id')], false);
+        } else {
             $this->createMigrator()->createForeignKey($doc->getReference('user_id'));
-
-            $user->createEntity()
-                ->set('name', 'Sarah')
-                ->save();
-
-            $doc->createEntity()
-                ->set('name', 'Invoice 7')
-                ->set('user_id', 1)
-                ->save();
-
-            self::assertSame([
-                [
-                    'id' => 1,
-                    'name' => 'Invoice 7',
-                    'user_id' => 1,
-                    'user' => 'Sarah',
-                ],
-            ], $doc->export());
         }
+
+        $user->createEntity()
+            ->set('name', 'Sarah')
+            ->save();
+
+        $doc->createEntity()
+            ->set('name', 'Invoice 7')
+            ->set('user_id', 1)
+            ->save();
+
+        self::assertSame([
+            [
+                'id' => 1,
+                'name' => 'Invoice 7',
+                'user_id' => 1,
+                'user' => 'Sarah',
+            ],
+        ], $doc->export());
     }
 }