feat(sqlite): gate MariaDB-shape emulation behind setEmulateMySQL flag

Vanilla SQLite stays vanilla by default; opt in to MariaDB-shaped
behaviour via setEmulateMySQL(true). When the flag is on:
- _tenant declares as INT(11) UNSIGNED instead of INTEGER
- parseSqliteColumnType maps INTEGER → 'int' and reports MariaDB byte
  ceilings / numeric precision defaults to match INFORMATION_SCHEMA
- updateAttribute scans on resize-down and raises TruncateException
- getSupportForAttributeResizing returns true

Native SQLite features stay unconditionally on:
- ON CONFLICT DO UPDATE upserts
- REGEXP via the registered PCRE UDF
- FTS5 fulltext, relationships, schema introspection,
  composite UNIQUE under shared tables (via getSQLIndex auto-prepend)

Adapter test classes opt in to emulation so the existing test contract
(MariaDB-shaped column metadata, resize-down failures) keeps passing.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: abnegate

src/Database/Adapter/SQLite.php

@@ -45,13 +45,39 @@ class SQLite extends MariaDB
     private const MARIADB_MEDIUMTEXT_BYTES = '16777215';
     private const MARIADB_LONGTEXT_BYTES = '4294967295';
 
+    /**
+     * When enabled, the adapter reports MariaDB-shaped column metadata,
+     * advertises MariaDB-only capabilities (upserts, attribute resizing,
+     * PCRE regex via the registered UDF), and declares schema-internal
+     * columns (e.g. `_tenant`) using MariaDB-style types so callers that
+     * inspect INFORMATION_SCHEMA-style results behave identically across
+     * both adapters. Off by default — vanilla SQLite stays vanilla.
+     */
+    protected bool $emulateMySQL = false;
+
     public function __construct(mixed $pdo)
     {
         parent::__construct($pdo);
 
         $this->registerUserFunctions();
     }
 
+    /**
+     * Toggle MariaDB/MySQL emulation. See $emulateMySQL for what this
+     * actually changes.
+     */
+    public function setEmulateMySQL(bool $emulate): static
+    {
+        $this->emulateMySQL = $emulate;
+
+        return $this;
+    }
+
+    public function getEmulateMySQL(): bool
+    {
+        return $this->emulateMySQL;
+    }
+
     /**
      * SQLite has no built-in regex operator — the inherited REGEXP path
      * relies on the connection supplying one. Register a PHP-implemented
@@ -209,7 +235,13 @@ public function createCollection(string $name, array $attributes = [], array $in
             $attributeStrings[$key] = "`{$attrId}` {$attrType}, ";
         }
 
-        $tenantQuery = $this->sharedTables ? '`_tenant` "INT(11) UNSIGNED" DEFAULT NULL,' : '';
+        // SQLite stores integers regardless of declared type, but
+        // testSchemaAttributes asserts the columnType reads back as
+        // `int(11) unsigned` to match MariaDB. Quote the declaration so
+        // PRAGMA table_info echoes the exact string under emulation;
+        // otherwise use INTEGER, the affinity-correct vanilla form.
+        $tenantType = $this->emulateMySQL ? '"INT(11) UNSIGNED"' : 'INTEGER';
+        $tenantQuery = $this->sharedTables ? "`_tenant` {$tenantType} DEFAULT NULL," : '';
 
         $collection = "
 			CREATE TABLE {$this->getSQLTable($id)} (
@@ -408,10 +440,11 @@ public function updateAttribute(string $collection, string $id, string $type, in
 
         // SQLite is dynamically typed — `ALTER TABLE ... MODIFY COLUMN` is
         // not supported and a smaller declared size silently accepts
-        // larger values. To keep parity with the MariaDB contract that
-        // resize-down rejects when data exceeds the new size, scan the
-        // column ourselves and raise the same TruncateException.
-        if ($type === Database::VAR_STRING && $size > 0 && !$array) {
+        // larger values. Under MySQL emulation, scan the column and
+        // raise the same TruncateException MariaDB throws. Off-
+        // emulation the declared size is metadata-only, so skip the
+        // scan and let the rename branch (if any) handle the rest.
+        if ($this->emulateMySQL && $type === Database::VAR_STRING && $size > 0 && !$array) {
             $name = $this->filter($collection);
             $column = $this->filter($id);
             $sql = "SELECT 1 FROM {$this->getSQLTable($name)} WHERE LENGTH(`{$column}`) > :max LIMIT 1";
@@ -1215,11 +1248,11 @@ public function getSupportForUpdateLock(): bool
      */
     public function getSupportForAttributeResizing(): bool
     {
-        // SQLite is dynamically typed with no MODIFY COLUMN, but
-        // updateAttribute scans the column on resize-down and raises
-        // TruncateException when any row exceeds the new size — same
-        // contract MariaDB enforces via the engine.
-        return true;
+        // SQLite is dynamically typed with no MODIFY COLUMN. When
+        // emulating MySQL, updateAttribute scans the column on
+        // resize-down and raises TruncateException to match MariaDB's
+        // contract. Off-emulation, declared sizes are metadata-only.
+        return $this->emulateMySQL;
     }
 
     /**
@@ -1254,6 +1287,7 @@ public function getSupportForSchemaIndexes(): bool
      */
     public function getSupportForUpserts(): bool
     {
+        // ON CONFLICT DO UPDATE is native SQLite, not MariaDB emulation.
         return true;
     }
 
@@ -2197,6 +2231,9 @@ public function getSupportNonUtfCharacters(): bool
      */
     public function getSupportForPCRERegex(): bool
     {
+        // The REGEXP UDF is registered unconditionally in the
+        // constructor and runs preg_match (PCRE) — same surface as
+        // MariaDB's native operator from the caller's perspective.
         return true;
     }
 
@@ -2581,10 +2618,11 @@ private function parseSqliteColumnType(string $declaration): array
         }
 
         $dataType = \strtolower($base);
-        // SQLite spells INT and INTEGER interchangeably for declared types,
-        // but MariaDB's INFORMATION_SCHEMA always reports `int`. Canonicalise
-        // so getSchemaAttributes matches the parent contract.
-        if ($dataType === 'integer') {
+        // SQLite spells INT and INTEGER interchangeably for declared types.
+        // Under emulation, canonicalise to MariaDB's reported `int` so
+        // getSchemaAttributes matches that adapter's contract; otherwise
+        // keep the verbatim form the user declared.
+        if ($this->emulateMySQL && $dataType === 'integer') {
             $dataType = 'int';
         }
 
@@ -2596,6 +2634,12 @@ private function parseSqliteColumnType(string $declaration): array
             'datetimePrecision' => null,
         ];
 
+        // VARCHAR / CHAR / DATETIME(n) / DECIMAL(p,s) length+precision
+        // come straight from the declaration — that's true for vanilla
+        // SQLite too. The MariaDB byte ceilings (TEXT/MEDIUMTEXT/etc.)
+        // and the integer/float precision defaults are MariaDB-specific
+        // INFORMATION_SCHEMA conventions, so report them only under
+        // emulation.
         switch ($dataType) {
             case 'varchar':
             case 'char':
@@ -2604,19 +2648,6 @@ private function parseSqliteColumnType(string $declaration): array
                 }
                 break;
 
-            case 'text':
-                $result['characterMaximumLength'] = self::MARIADB_TEXT_BYTES;
-                break;
-
-            case 'mediumtext':
-                $result['characterMaximumLength'] = self::MARIADB_MEDIUMTEXT_BYTES;
-                break;
-
-            case 'longtext':
-            case 'json':
-                $result['characterMaximumLength'] = self::MARIADB_LONGTEXT_BYTES;
-                break;
-
             case 'datetime':
             case 'timestamp':
             case 'time':
@@ -2625,40 +2656,70 @@ private function parseSqliteColumnType(string $declaration): array
                 }
                 break;
 
-            case 'tinyint':
-                $result['numericPrecision'] = '3';
+            case 'decimal':
+            case 'numeric':
+                if ($argument !== null) {
+                    $result['numericPrecision'] = (string) $argument;
+                }
+                if ($secondArgument !== null) {
+                    $result['numericScale'] = (string) $secondArgument;
+                } elseif ($this->emulateMySQL && $argument !== null) {
+                    $result['numericScale'] = '0';
+                }
                 break;
+        }
 
-            case 'smallint':
-                $result['numericPrecision'] = '5';
-                break;
+        if ($this->emulateMySQL) {
+            switch ($dataType) {
+                case 'text':
+                    $result['characterMaximumLength'] = self::MARIADB_TEXT_BYTES;
+                    break;
 
-            case 'mediumint':
-                $result['numericPrecision'] = '7';
-                break;
+                case 'mediumtext':
+                    $result['characterMaximumLength'] = self::MARIADB_MEDIUMTEXT_BYTES;
+                    break;
 
-            case 'int':
-            case 'integer':
-                $result['numericPrecision'] = '10';
-                break;
+                case 'longtext':
+                case 'json':
+                    $result['characterMaximumLength'] = self::MARIADB_LONGTEXT_BYTES;
+                    break;
 
-            case 'bigint':
-                $result['numericPrecision'] = '19';
-                break;
+                case 'tinyint':
+                    $result['numericPrecision'] = '3';
+                    break;
 
-            case 'decimal':
-            case 'numeric':
-                $result['numericPrecision'] = $argument !== null ? (string) $argument : '10';
-                $result['numericScale'] = $secondArgument !== null ? (string) $secondArgument : '0';
-                break;
+                case 'smallint':
+                    $result['numericPrecision'] = '5';
+                    break;
 
-            case 'float':
-                $result['numericPrecision'] = '12';
-                break;
+                case 'mediumint':
+                    $result['numericPrecision'] = '7';
+                    break;
 
-            case 'double':
-                $result['numericPrecision'] = '22';
-                break;
+                case 'int':
+                case 'integer':
+                    $result['numericPrecision'] = '10';
+                    break;
+
+                case 'bigint':
+                    $result['numericPrecision'] = '19';
+                    break;
+
+                case 'decimal':
+                case 'numeric':
+                    if ($result['numericPrecision'] === null) {
+                        $result['numericPrecision'] = '10';
+                    }
+                    break;
+
+                case 'float':
+                    $result['numericPrecision'] = '12';
+                    break;
+
+                case 'double':
+                    $result['numericPrecision'] = '22';
+                    break;
+            }
         }
 
         return $result;

tests/e2e/Adapter/SQLiteTest.php

@@ -39,7 +39,10 @@ public function getDatabase(): Database
         $redis->flushAll();
         $cache = new Cache(new RedisAdapter($redis));
 
-        $database = new Database(new SQLite($pdo), $cache);
+        $adapter = new SQLite($pdo);
+        $adapter->setEmulateMySQL(true);
+
+        $database = new Database($adapter, $cache);
         $database
             ->setAuthorization(self::$authorization)
             ->setDatabase('utopiaTests')

tests/e2e/Adapter/SharedTables/SQLiteTest.php

@@ -52,7 +52,10 @@ public function getDatabase(): Database
 
         $cache = new Cache(new RedisAdapter($redis));
 
-        $database = new Database(new SQLite($pdo), $cache);
+        $adapter = new SQLite($pdo);
+        $adapter->setEmulateMySQL(true);
+
+        $database = new Database($adapter, $cache);
         $database
             ->setAuthorization(self::$authorization)
             ->setDatabase('utopiaTests')