@an5/adapters 0.2.6 → 0.2.9

package/dotnet/Sqlite/SqliteEngine.cs

@@ -0,0 +1,214 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Reflection;
+
+namespace An5Orm
+{
+    // ─── SQLite Engine ──────────────────────────────────────────────────────────
+    //
+    // Microsoft.Data.Sqlite is a different type family from the other two
+    // providers (SqliteConnection/SqliteCommand, not DbConnection subclasses you
+    // can reuse), so it gets its own engine rather than a shared abstraction.
+    //
+    // Notable differences from MSSQL, all handled by the SQL builder in
+    // An5Adapter rather than here: no WITH (NOLOCK) table hint, no SELECT TOP,
+    // LIMIT/OFFSET instead of OFFSET/FETCH NEXT, and no stored procedures.
+
+    internal class SqliteEngine : IQueryEngine
+    {
+        public Dialect Dialect => Dialect.Sqlite;
+        private readonly string _connectionString;
+        private readonly int _commandTimeout;
+
+        public SqliteEngine(string connectionString, int commandTimeout)
+        {
+            _connectionString = SqliteConnectionString.Normalize(connectionString);
+            _commandTimeout = commandTimeout;
+        }
+
+        // Set while a transaction is open; statements then join it instead of
+        // opening a second connection, which SQLite would refuse.
+        private Microsoft.Data.Sqlite.SqliteConnection _txnConn;
+
+        private Microsoft.Data.Sqlite.SqliteConnection OpenNewConnection()
+        {
+            var conn = new Microsoft.Data.Sqlite.SqliteConnection(_connectionString);
+            conn.Open();
+            // WAL keeps readers from blocking the writer, and foreign keys are
+            // off by default in SQLite even when the schema declares them.
+            using var pragma = conn.CreateCommand();
+            pragma.CommandText = "PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;";
+            pragma.ExecuteNonQuery();
+            return conn;
+        }
+
+        private ConnectionScope<Microsoft.Data.Sqlite.SqliteConnection> Acquire()
+            => _txnConn != null
+                ? new ConnectionScope<Microsoft.Data.Sqlite.SqliteConnection>(_txnConn, owned: false)
+                : new ConnectionScope<Microsoft.Data.Sqlite.SqliteConnection>(OpenNewConnection(), owned: true);
+
+        private Microsoft.Data.Sqlite.SqliteCommand BuildCommand(
+            Microsoft.Data.Sqlite.SqliteConnection conn, string sql, Dictionary<string, object> parameters)
+        {
+            var cmd = conn.CreateCommand();
+            cmd.CommandText = sql;
+            cmd.CommandTimeout = _commandTimeout;
+            if (parameters != null)
+            {
+                foreach (var kv in parameters)
+                {
+                    // SqliteParameter names must not carry the prefix; the SQL
+                    // keeps @name and the parameter is registered as name.
+                    var paramName = kv.Key.TrimStart('@');
+                    var value = kv.Value ?? DBNull.Value;
+
+                    var param = cmd.CreateParameter();
+                    param.ParameterName = paramName;
+                    // A JSON vector or a bool needs a type SQLite will store in a
+                    // column rather than coerce to an integer.
+                    if (value is bool flag) param.Value = flag ? 1 : 0;
+                    else param.Value = value;
+                    cmd.Parameters.Add(param);
+                }
+            }
+            return cmd;
+        }
+
+        public List<Dictionary<string, object>> QueryRaw(string sql, Dictionary<string, object> parameters)
+        {
+            var results = new List<Dictionary<string, object>>();
+            using var scope = Acquire();
+            using var cmd = BuildCommand(scope.Connection, sql, parameters);
+            using var reader = cmd.ExecuteReader();
+            while (reader.Read())
+            {
+                var row = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+                for (int i = 0; i < reader.FieldCount; i++)
+                {
+                    row[reader.GetName(i)] = reader.IsDBNull(i) ? null : reader.GetValue(i);
+                }
+                results.Add(row);
+            }
+            return results;
+        }
+
+        public List<T> QueryRaw<T>(string sql, Dictionary<string, object> parameters) where T : new()
+        {
+            var results = new List<T>();
+            using var scope = Acquire();
+            using var cmd = BuildCommand(scope.Connection, sql, parameters);
+            using var reader = cmd.ExecuteReader();
+            var props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
+            while (reader.Read())
+            {
+                var item = new T();
+                foreach (var prop in props)
+                {
+                    if (!HasColumn(reader, prop.Name)) continue;
+                    var val = reader[prop.Name];
+                    if (val == DBNull.Value) continue;
+                    try { prop.SetValue(item, Convert.ChangeType(val, prop.PropertyType)); } catch { }
+                }
+                results.Add(item);
+            }
+            return results;
+        }
+
+        public int ExecuteRaw(string sql, Dictionary<string, object> parameters)
+        {
+            using var scope = Acquire();
+            using var cmd = BuildCommand(scope.Connection, sql, parameters);
+            return cmd.ExecuteNonQuery();
+        }
+
+        private static bool HasColumn(Microsoft.Data.Sqlite.SqliteDataReader reader, string name)
+        {
+            for (int i = 0; i < reader.FieldCount; i++)
+                if (reader.GetName(i).Equals(name, StringComparison.OrdinalIgnoreCase)) return true;
+            return false;
+        }
+
+        /// <summary>Detaches the transaction connection, so later statements open their own.</summary>
+        internal void ReleaseTransactionConnection() => _txnConn = null;
+
+        public An5TransactionBase BeginTransaction()
+        {
+            if (_txnConn != null)
+                throw new InvalidOperationException("A transaction is already open on this adapter.");
+            var conn = OpenNewConnection();
+            var tx = conn.BeginTransaction();
+            _txnConn = conn;
+            return new SqliteTransaction(this, conn, tx);
+        }
+    }
+
+    internal class SqliteTransaction : An5TransactionBase
+    {
+        private readonly SqliteEngine _engine;
+        private readonly Microsoft.Data.Sqlite.SqliteConnection _conn;
+        private readonly Microsoft.Data.Sqlite.SqliteTransaction _tx;
+
+        public SqliteTransaction(SqliteEngine engine, Microsoft.Data.Sqlite.SqliteConnection conn, Microsoft.Data.Sqlite.SqliteTransaction tx)
+        {
+            _engine = engine;
+            _conn = conn;
+            _tx = tx;
+        }
+
+        public override void Commit() { _tx.Commit(); }
+
+        public override void Rollback() { _tx.Rollback(); }
+
+        public override void Dispose()
+        {
+            _engine.ReleaseTransactionConnection();
+            _tx.Dispose();
+            _conn.Dispose();
+        }
+    }
+
+    // ─── Connection string normalisation ──────────────────────────────────────
+
+    internal static class SqliteConnectionString
+    {
+        /// <summary>
+        /// Turns the accepted spellings into a Data Source string.
+        ///
+        /// Microsoft.Data.Sqlite only understands `Data Source=`, so the bare
+        /// paths and `sqlite:` URLs the rest of the ORM accepts have to be
+        /// rewritten. An in-memory database has to stay open for the life of the
+        /// connection, which is why callers keep one connection per operation
+        /// open only for the duration of a statement.
+        /// </summary>
+        public static string Normalize(string connectionString)
+        {
+            var cs = (connectionString ?? "").Trim();
+            if (cs.Length == 0) return "Data Source=:memory:";
+
+            // Already a Microsoft.Data.Sqlite connection string.
+            if (cs.IndexOf("Data Source", StringComparison.OrdinalIgnoreCase) >= 0
+                || cs.IndexOf("DataSource", StringComparison.OrdinalIgnoreCase) >= 0
+                || cs.IndexOf("Mode", StringComparison.OrdinalIgnoreCase) >= 0)
+                return cs;
+
+            if (cs == ":memory:")
+                return "Data Source=:memory:";
+
+            if (cs.StartsWith("sqlite://", StringComparison.OrdinalIgnoreCase))
+                return "Data Source=" + cs.Substring("sqlite://".Length);
+
+            if (cs.StartsWith("sqlite:", StringComparison.OrdinalIgnoreCase))
+            {
+                // `sqlite:app.db` and `sqlite::memory:`
+                return "Data Source=" + cs.Substring("sqlite:".Length);
+            }
+
+            if (cs.StartsWith("file:", StringComparison.OrdinalIgnoreCase))
+                return cs; // SQLite URI, understood as-is.
+
+            // A bare path.
+            return "Data Source=" + cs;
+        }
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@an5/adapters",
-  "version": "0.2.6",
-  "description": "Standalone language adapters for AN5 ORM - TypeScript, Python, .NET, Go, and Google Sheets query execution.",
+  "version": "0.2.9",
+  "description": "Standalone language adapters for AN5 ORM - TypeScript, Python, .NET, Go, Rust, and Google Sheets query execution.",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -21,7 +21,9 @@
     "./typescript/*": "./dist/*",
     "./python": "./python/an5_adapter.py",
     "./dotnet": "./dotnet/An5Adapter.cs",
-    "./golang": "./golang/an5_adapter.go"
+    "./golang": "./golang/an5_adapter.go",
+    "./rust": "./rust/Cargo.toml",
+    "./nbase": "./dist/nbase/index.js"
   },
   "author": "an5ORM",
   "homepage": "https://github.com/an5ORM/an5",
@@ -37,7 +39,8 @@
     "python",
     "dotnet",
     "go",
-    "golang"
+    "golang",
+    "rust"
   ],
   "files": [
     "dist/**/*.{js,d.ts}",
@@ -45,19 +48,23 @@
     "python/**/*.py",
     "dotnet/**/*",
     "golang/**/*",
-    "README.md"
+    "rust/Cargo.toml",
+    "rust/src/**/*",
+    "README.md",
+    "typescript/src/nbase/**/*.ts"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "pretest": "npm run build",
     "prepack": "npm run build",
     "build:python": "(python -m build --outdir dist-py || python3 -m build --outdir dist-py)",
-    "test": "node test/unit.test.js && node test/package.test.js",
+    "test": "node test/unit.test.js && node test/package.test.js && node test/nbase.test.js && node --test test/version-sync.test.js",
     "test:package:smoke": "node scripts/package-smoke.js",
     "test:integration:live": "node test/live-db.integration.test.js",
     "test:python": "(python -m compileall python 2>&1 || python3 -m compileall python 2>&1)",
-    "test:dotnet": "node scripts/dotnet-compile-check.js",
-    "test:go": "cd golang && go test ./..."
+    "test:dotnet": "node scripts/dotnet-compile-check.js && node scripts/dotnet-sqlite-smoke.js",
+    "test:go": "cd golang && go test ./...",
+    "test:rust": "node scripts/rust-compile-check.js"
   },
   "dependencies": {
     "googleapis": "^134.0.0",

package/python/an5_adapter.py

@@ -3,14 +3,16 @@
 from typing import Dict, List, Optional, Any
 
 try:
-    from .base import DIALECT_MSSQL, DIALECT_POSTGRES, detect_dialect, set_adapter_metadata
+    from .base import DIALECT_MSSQL, DIALECT_POSTGRES, DIALECT_SQLITE, detect_dialect, set_adapter_metadata
     from .mssql import connect as connect_mssql
     from .postgres import connect as connect_postgres
+    from .sqlite import connect as connect_sqlite, is_memory as is_sqlite_memory
     from .table_client import AdapterTableClient, ViewClient
 except ImportError:
-    from base import DIALECT_MSSQL, DIALECT_POSTGRES, detect_dialect, set_adapter_metadata
+    from base import DIALECT_MSSQL, DIALECT_POSTGRES, DIALECT_SQLITE, detect_dialect, set_adapter_metadata
     from mssql import connect as connect_mssql
     from postgres import connect as connect_postgres
+    from sqlite import connect as connect_sqlite, is_memory as is_sqlite_memory
     from table_client import AdapterTableClient, ViewClient
 
 # Backward-compatible aliases used by tests and older imports.
@@ -24,12 +26,38 @@ class An5Adapter:
     def __init__(self, connection_string: str):
         self._dialect = detect_dialect(connection_string)
         self._conn_str = connection_string
+        # The open connection of `transaction()`, when there is one. Every
+        # statement in the callback has to use this very connection, otherwise a
+        # rollback returns to a different, already committed connection — that
+        # is "the error was raised but the data is still there".
+        self._txn_conn = None
+        # Long-lived connection for in-memory databases, because `:memory:` is
+        # gone as soon as every connection is closed.
+        self._conn = None
 
     def _connect(self):
         if self._dialect == DIALECT_POSTGRES:
             return connect_postgres(self._conn_str)
+        if self._dialect == DIALECT_SQLITE:
+            return connect_sqlite(self._conn_str)
         return connect_mssql(self._conn_str)
 
+    def _acquire(self):
+        """Returns (connection, whether we opened it and must close it)."""
+        if self._txn_conn is not None:
+            return self._txn_conn, False
+        if self._dialect == DIALECT_SQLITE and is_sqlite_memory(self._conn_str):
+            if self._conn is None:
+                self._conn = self._connect()
+            return self._conn, False
+        return self._connect(), True
+
+    def close(self):
+        """Closes the long-lived connection (in-memory databases only)."""
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None
+
     def _to_dicts(self, cursor, query: str) -> List[Dict]:
         if cursor.description:
             cols = [col[0] for col in cursor.description]
@@ -38,22 +66,24 @@ class An5Adapter:
         return []
 
     def exec(self, query: str, params: Optional[List] = None) -> List[Dict]:
-        conn = self._connect()
+        conn, owned = self._acquire()
         try:
             cursor = conn.cursor()
             cursor.execute(query, params or [])
             return self._to_dicts(cursor, query)
         finally:
-            conn.close()
+            if owned:
+                conn.close()
 
     def execute(self, query: str, params: Optional[List] = None) -> int:
-        conn = self._connect()
+        conn, owned = self._acquire()
         try:
             cursor = conn.cursor()
             cursor.execute(query, params or [])
             return cursor.rowcount
         finally:
-            conn.close()
+            if owned:
+                conn.close()
 
     def query_raw(self, query: str, *values) -> List[Dict]:
         return self.exec(query, list(values))
@@ -68,6 +98,15 @@ class An5Adapter:
         return ViewClient(self, view_name)
 
     def query_proc(self, proc_name: str, params: Optional[List] = None) -> List[Dict]:
+        if self._dialect == DIALECT_SQLITE:
+            # SQLite has no stored procedures. This used to fall through to the
+            # MSSQL branch and generate `EXEC ...`, which is not valid SQL, and
+            # the error only surfaced at the call. Saying so beats sending wrong
+            # SQL.
+            raise NotImplementedError(
+                "SQLite has no stored procedures. Use the generated table client "
+                "(db.<model>.*) or db.exec() with a parameterised query."
+            )
         if self._dialect == DIALECT_POSTGRES:
             placeholders = ", ".join(["%s"] * len(params or []))
             sql = f"CALL {proc_name}({placeholders})" if placeholders else f"CALL {proc_name}()"
@@ -77,6 +116,11 @@ class An5Adapter:
         return self.exec(sql, params or [])
 
     def execute_proc(self, proc_name: str, params: Optional[List] = None) -> int:
+        if self._dialect == DIALECT_SQLITE:
+            raise NotImplementedError(
+                "SQLite has no stored procedures. Use the generated table client "
+                "(db.<model>.*) or db.execute() with a parameterised query."
+            )
         if self._dialect == DIALECT_POSTGRES:
             placeholders = ", ".join(["%s"] * len(params or []))
             sql = f"CALL {proc_name}({placeholders})" if placeholders else f"CALL {proc_name}()"
@@ -89,8 +133,24 @@ class An5Adapter:
         return self.table(model_name)
 
     def transaction(self, fn):
-        conn = self._connect()
-        conn.autocommit = False
+        if self._txn_conn is not None:
+            raise RuntimeError("Nested transaction() is not supported")
+        # In-memory database: the connection holding the data has to be reused.
+        # Opening a new one here points at a different, empty database — the
+        # table just created disappears and every statement in the transaction
+        # fails.
+        conn = self._conn if self._conn is not None else self._connect()
+        owned = self._conn is None
+        if self._dialect == DIALECT_SQLITE:
+            # `sqlite3.Connection` has no `autocommit` attribute; transactions
+            # are driven by `isolation_level`. The provider opens at `None`
+            # (autocommit), so to get a transaction it has to be set back to `""`
+            # and sqlite3 opens an implicit BEGIN before each DML statement —
+            # only then do `commit()`/`rollback()` do anything.
+            conn.isolation_level = ""
+        else:
+            conn.autocommit = False
+        self._txn_conn = conn
         try:
             result = fn(self)
             conn.commit()
@@ -99,9 +159,13 @@ class An5Adapter:
             conn.rollback()
             raise
         finally:
+            self._txn_conn = None
             if self._dialect == DIALECT_POSTGRES:
                 conn.autocommit = True
-            conn.close()
+            elif self._dialect == DIALECT_SQLITE:
+                conn.isolation_level = None
+            if owned:
+                conn.close()
 
 def create_an5_adapter(connection_string: str) -> An5Adapter:
     return An5Adapter(connection_string)
@@ -113,6 +177,7 @@ __all__ = [
     "create_an5_adapter",
     "DIALECT_MSSQL",
     "DIALECT_POSTGRES",
+    "DIALECT_SQLITE",
     "_detect_dialect",
     "_parse_connection_string",
     "set_adapter_metadata",

package/python/base/__init__.py

@@ -1,3 +1,3 @@
-from .dialects import DIALECT_MSSQL, DIALECT_POSTGRES, detect_dialect
+from .dialects import DIALECT_MSSQL, DIALECT_POSTGRES, DIALECT_SQLITE, detect_dialect
 from .metadata import model_to_table, model_fields, relation_map, set_adapter_metadata, get_relations_for_model, get_model_to_table, get_fields_for_model
 from .sql import _quote, _parse_where, _build_order_by, _resolve_table, _quote_table

package/python/base/metadata.py

@@ -25,11 +25,35 @@ def set_adapter_metadata(metadata: Dict[str, Any]) -> None:
                         "localKey": defn.get("localKey") or defn.get("local_key") or "",
                     }
 
+def resolve_model_key(model_name: str) -> str:
+    """The model name in the metadata, accepting a different capitalisation.
+
+    The generated client registers tables under their PascalCase name
+    (`CatalogType`) while the metadata keys them camelCase/snake_case
+    (`catalogType`, `catalog_type`). A plain lookup would find no columns at all
+    and silently skip `isId` — that is, never generate the primary key.
+    """
+    if not model_name:
+        return model_name
+    if model_name in model_to_table or model_name in model_fields:
+        return model_name
+    camel = model_name[0].lower() + model_name[1:]
+    if camel in model_to_table or camel in model_fields:
+        return camel
+    lower = model_name.lower()
+    if lower in model_to_table or lower in model_fields:
+        return lower
+    return model_name
+
+
 def get_relations_for_model(model_name: str) -> Dict[str, Dict[str, str]]:
-    return relation_map.get(model_name) or {}
+    return relation_map.get(model_name) or relation_map.get(resolve_model_key(model_name)) or {}
 
 def get_model_to_table() -> Dict[str, str]:
     return dict(model_to_table)
 
 def get_fields_for_model(model_name: str) -> Any:
+    key = resolve_model_key(model_name)
+    if key in model_fields:
+        return model_fields[key]
     return model_fields.get(model_name)

package/python/base/sql.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, List, Optional
 from .dialects import DIALECT_MSSQL, DIALECT_POSTGRES, DIALECT_SQLITE
-from .metadata import model_to_table, model_fields
+from .metadata import model_to_table, model_fields, resolve_model_key
 
 # ─── Quoting ───────────────────────────────────────────────────────────────────────
 
@@ -152,21 +152,51 @@ def _build_order_by(order_by: Any, dialect: str) -> str:
 # ─── Table name resolution ─────────────────────────────────────────────────────────
 
 def _resolve_table(model_name: str) -> str:
-    if model_name in model_to_table:
-        return model_to_table[model_name]
-    camel = model_name[0].lower() + model_name[1:] if model_name else model_name
-    if camel in model_to_table:
-        return model_to_table[camel]
-    lower = model_name.lower()
-    if lower in model_to_table:
-        return model_to_table[lower]
+    key = resolve_model_key(model_name)
+    if key in model_to_table:
+        return model_to_table[key]
     return model_name
 
 
+def _split_qualified(t: str) -> List[str]:
+    """Splits `schema.table` without cutting a dot that sits inside brackets.
+
+    The generated metadata is always MSSQL-shaped: `[dbo].[users]`. A plain
+    `split(".")` yields `['[dbo]', '[users]']` — right for MSSQL, but moving to
+    PostgreSQL/SQLite means stripping the old brackets and re-quoting for the
+    target dialect, otherwise `[dbo].[users]` stays as-is and the table name
+    comes out wrong.
+    """
+    parts: List[str] = []
+    buf: List[str] = []
+    open_ch = ""
+    close_ch = ""
+    for ch in t:
+        if open_ch:
+            buf.append(ch)
+            if ch == close_ch:
+                open_ch = ""
+                close_ch = ""
+            continue
+        if ch in ("[", '"'):
+            open_ch, close_ch = ch, ("]" if ch == "[" else '"')
+            buf.append(ch)
+            continue
+        if ch == ".":
+            parts.append("".join(buf))
+            buf = []
+            continue
+        buf.append(ch)
+    parts.append("".join(buf))
+    return [p for p in parts if p]
+
+
 def _quote_table(t: str, dialect: str) -> str:
-    if t.startswith("[") or t.startswith('"'):
-        return t
-    if "." in t:
-        return ".".join(_quote(p, dialect) for p in t.split("."))
-    return _quote(t, dialect)
+    # Never return an already bracketed `[...]` name as-is: that quoting is only
+    # correct on MSSQL. Other dialects have to strip it and re-quote, or the
+    # previous dialect's brackets follow the name into the new dialect.
+    parts = _split_qualified(str(t))
+    if not parts:
+        parts = [str(t)]
+    return ".".join(_quote(p, dialect) for p in parts)
 

package/python/sqlite/__init__.py

@@ -0,0 +1,3 @@
+from .provider import connect, is_memory, parse_connection_string, placeholder
+
+__all__ = ["connect", "is_memory", "parse_connection_string", "placeholder"]

package/python/sqlite/provider.py

@@ -0,0 +1,83 @@
+"""SQLite provider — uses the standard library `sqlite3`, no extra driver needed.
+
+Why it exists: `base/dialects.py` already had `DIALECT_SQLITE` and the SQL layer
+already used the `?` placeholder for it, but with no provider `An5Adapter._connect`
+fell back to MSSQL — every statement then carried `WITH (NOLOCK)` and
+`OFFSET ... FETCH NEXT`, SQL SQLite does not understand, failing on the first one.
+
+Why `isolation_level=None`: `sqlite3` opens an implicit transaction before each DML
+statement by default, so `An5Adapter.exec` (which opens/closes a connection per
+statement) would leave transactions dangling. `None` means autocommit, matching the
+`pyodbc.connect(..., autocommit=True)` of the MSSQL provider.
+"""
+
+import sqlite3
+from typing import Tuple
+
+# Strip the `sqlite:`/`sqlite://`/`sqlite:///` wrapper first, only then look for
+# `file:`. Two steps are required because `sqlite:file::memory:?cache=shared` only
+# becomes a URI after `sqlite:` is removed; checking once would miss it and sqlite3
+# would treat the whole thing as a file name.
+_SQLITE_PREFIXES = ("sqlite:///", "sqlite://", "sqlite:")
+_FILE_PREFIX = "file:"
+
+
+def parse_connection_string(url: str) -> Tuple[str, bool]:
+    """Returns (path/URI, whether sqlite3 should treat it as a URI).
+
+    Accepts `sqlite:///path`, `sqlite:path`, `file:path` and a bare path.
+    `file:` has to return URI=True because sqlite3 only understands URIs with the
+    `uri` flag on.
+    """
+    value = (url or "").strip()
+    for prefix in _SQLITE_PREFIXES:
+        if value.lower().startswith(prefix):
+            value = value[len(prefix):]
+            break
+    is_uri = value.lower().startswith(_FILE_PREFIX)
+    if is_uri:
+        # Keep the `file:` prefix — sqlite3 needs the full URI form
+        # (`file::memory:?cache=shared`); without it `:memory:?cache=shared` is
+        # no longer a valid URI.
+        return value, True
+    # On Windows `sqlite:///C:/path/x.db` is left with `/C:/path/x.db`; the
+    # leading slash belongs to the URL, not to the path.
+    if len(value) > 2 and value[0] == "/" and value[2] == ":":
+        value = value[1:]
+    return value or ":memory:", is_uri
+
+
+def is_memory(url: str) -> bool:
+    """An in-memory database does not survive every connection being closed.
+
+    The adapter opens/closes a connection per statement, so with a plain
+    `:memory:` the data disappears after the first statement (the table just
+    CREATEd is gone). The adapter therefore has to hold a long-lived connection
+    for this case; see `An5Adapter._acquire`.
+    """
+    target, is_uri = parse_connection_string(url)
+    if is_uri:
+        # `parse_connection_string` returns the whole URI (with `file:`).
+        inner = target[len(_FILE_PREFIX):] if target.lower().startswith(_FILE_PREFIX) else target
+        return inner.startswith(":memory:") or "mode=memory" in inner
+    return target == ":memory:"
+
+def connect(connection_string: str):
+    target, is_uri = parse_connection_string(connection_string)
+    conn = sqlite3.connect(
+        target,
+        isolation_level=None,
+        check_same_thread=False,
+        uri=is_uri,
+    )
+    # There is no `NOLOCK`; WAL lets concurrent readers and writers proceed
+    # without blocking each other, and foreign_keys is enabled because SQLite
+    # defaults it OFF (unlike every other dialect).
+    conn.execute("PRAGMA foreign_keys = ON")
+    if not is_memory(connection_string) and not is_uri:
+        conn.execute("PRAGMA journal_mode = WAL")
+    return conn
+
+
+def placeholder() -> str:
+    return "?"