@an5/adapters 0.2.6 → 0.2.10

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.10",
+  "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,22 +48,26 @@
     "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 && node --test test/query-semantics.test.js && node test/query-relations.integration.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:integration:live": "node test/live-db.integration.test.js && node test/query-relations.integration.test.js",
+    "test:python": "node scripts/python-tests.js",
+    "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",
+    "googleapis": "^183.0.0",
     "mssql": "^12.5.5",
     "pg": "^8.13.0"
   },
@@ -72,5 +79,13 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "peerDependencies": {
+    "mysql2": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "mysql2": {
+      "optional": true
+    }
   }
 }

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 ───────────────────────────────────────────────────────────────────────
 
@@ -51,10 +51,8 @@ def _parse_where(model_name: str, where: Optional[Dict], params: Dict, dialect:
 
     for key, value in clean_where.items():
         if key == "OR" and isinstance(value, list):
-            sub = [_parse_where(model_name, v, params, dialect, f"{prefix}or{i}_") for i, v in enumerate(value)]
-            sub = [s for s in sub if s]
-            if sub:
-                conditions.append(f"({' OR '.join(sub)})")
+            sub = [_parse_where(model_name, v, params, dialect, f"{prefix}or{i}_") or "1=1" for i, v in enumerate(value)]
+            conditions.append(f"({' OR '.join(sub)})" if sub else "1=0")
         elif key == "AND":
             items = value if isinstance(value, list) else [value]
             sub = [_parse_where(model_name, v, params, dialect, f"{prefix}and{i}_") for i, v in enumerate(items)]
@@ -63,10 +61,9 @@ def _parse_where(model_name: str, where: Optional[Dict], params: Dict, dialect:
                 conditions.append(f"({' AND '.join(sub)})")
         elif key == "NOT":
             items = value if isinstance(value, list) else [value]
-            sub = [_parse_where(model_name, v, params, dialect, f"{prefix}not{i}_") for i, v in enumerate(items)]
-            sub = [s for s in sub if s]
+            sub = [_parse_where(model_name, v, params, dialect, f"{prefix}not{i}_") or "1=1" for i, v in enumerate(items)]
             if sub:
-                conditions.append(f"NOT ({' AND '.join(sub)})")
+                conditions.append(f"NOT ({' OR '.join(sub)})")
         else:
             col = _quote(key, dialect)
             pname = _sanitize_param_name(f"{prefix}{key}")
@@ -152,21 +149,53 @@ 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 dialect == DIALECT_SQLITE and len(parts) == 2 and _strip_wrapping(_strip_wrapping(parts[0], "[", "]"), '"', '"').lower() == "dbo":
+        parts = parts[1:]
+    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 "?"

package/python/table_client.py

@@ -4,9 +4,9 @@ import json
 import uuid
 from typing import Any, Dict, Generic, List, Optional, TypeVar
 try:
-    from .base import DIALECT_MSSQL, DIALECT_POSTGRES, model_fields, _build_order_by, _parse_where, _quote, _quote_table, _resolve_table, get_relations_for_model
+    from .base import DIALECT_MSSQL, DIALECT_POSTGRES, DIALECT_SQLITE, get_fields_for_model, _build_order_by, _parse_where, _quote, _quote_table, _resolve_table, get_relations_for_model
 except ImportError:
-    from base import DIALECT_MSSQL, DIALECT_POSTGRES, model_fields, _build_order_by, _parse_where, _quote, _quote_table, _resolve_table, get_relations_for_model
+    from base import DIALECT_MSSQL, DIALECT_POSTGRES, DIALECT_SQLITE, get_fields_for_model, _build_order_by, _parse_where, _quote, _quote_table, _resolve_table, get_relations_for_model
 
 # ─── Select / Include helpers ────────────────────────────────────────────────────────
 
@@ -179,7 +179,11 @@ def _to_non_negative_int(value: Any, fallback: int = 0) -> int:
 
 def _append_update_set(set_parts: List[str], values: List[Any], col: str, val: Any, dialect: str) -> None:
     quoted = _quote(col, dialect)
-    placeholder = "?" if dialect == DIALECT_MSSQL else "%s"
+    # Only PostgreSQL uses `%s`; MSSQL and SQLite both use `?`. The condition is
+    # written as "is it Postgres" rather than "is it MSSQL" so a new dialect cannot
+    # fall into the `%s` branch by default — which once made SQLite generate SQL it
+    # could not parse.
+    placeholder = "%s" if dialect == DIALECT_POSTGRES else "?"
     if isinstance(val, dict):
         if "increment" in val:
             set_parts.append(f"{quoted} = {quoted} + {placeholder}")
@@ -232,22 +236,31 @@ class AdapterTableClient(Generic[T]):
 
     @property
     def _nolock(self) -> str:
-        return "" if self._dialect == DIALECT_POSTGRES else " WITH (NOLOCK)"
+        # `WITH (NOLOCK)` is an MSSQL table hint. PostgreSQL has none and SQLite
+        # has no equivalent concept at all — leaving it in makes every generated
+        # SELECT invalid SQL, failing on the first one.
+        return "" if self._dialect in (DIALECT_POSTGRES, DIALECT_SQLITE) else " WITH (NOLOCK)"
 
     @property
     def _fields(self) -> List[Dict]:
-        fields = model_fields.get(self._model, [])
+        # Uses the metadata resolver instead of a plain lookup: the generated
+        # client names tables in PascalCase while the metadata keys them in
+        # camelCase, so a plain lookup yields an empty list and silently skips
+        # `isId` (never generating the primary key).
+        fields = get_fields_for_model(self._model)
         if isinstance(fields, dict):
             raise TypeError(
                 "AN5 Python metadata is out of date. Regenerate with @an5/orm >= 1.0.4 "
                 "so MODEL_FIELDS uses a list of field objects."
             )
-        return fields
+        return fields or []
 
     def _pagination(self, take: Optional[int], skip: int, order_sql: str) -> str:
         if take is None:
             return ""
-        if self._dialect == DIALECT_POSTGRES:
+        if self._dialect in (DIALECT_POSTGRES, DIALECT_SQLITE):
+            # SQLite has `LIMIT ... OFFSET` like PostgreSQL. Taking the
+            # `OFFSET ... FETCH NEXT` branch produces SQL SQLite does not understand.
             return f" LIMIT {take} OFFSET {skip}"
         order_prefix = "" if order_sql else " ORDER BY (SELECT NULL)"
         return f"{order_prefix} OFFSET {skip} ROWS FETCH NEXT {take} ROWS ONLY"
@@ -304,7 +317,7 @@ class AdapterTableClient(Generic[T]):
 
         cols = [k for k, v in data.items() if v is not None]
         values = [data[c] for c in cols]
-        placeholders = ", ".join(["?" if self._dialect == DIALECT_MSSQL else "%s"] * len(cols))
+        placeholders = ", ".join(["%s" if self._dialect == DIALECT_POSTGRES else "?"] * len(cols))
         col_list = ", ".join(_quote(c, self._dialect) for c in cols)
         query = f"INSERT INTO {self._table_sql} ({col_list}) VALUES ({placeholders})"
         self._adapter.execute(query, values)
@@ -490,7 +503,7 @@ class AdapterTableClient(Generic[T]):
             query += f" ORDER BY {by_cols}"
         if has_take or has_skip:
             final_skip = _to_non_negative_int(skip)
-            if self._dialect == DIALECT_POSTGRES:
+            if self._dialect in (DIALECT_POSTGRES, DIALECT_SQLITE):
                 if has_take:
                     query += f" LIMIT {_to_non_negative_int(take, 1)}"
                 query += f" OFFSET {final_skip}"
@@ -508,34 +521,38 @@ class AdapterTableClient(Generic[T]):
         where_sql = _parse_where(self._model, where, params, self._dialect)
 
         # 1. Primary path: Native database SQL vector query execution (MSSQL VECTOR_DISTANCE / Postgres pgvector)
-        try:
-            field_sql = _quote(vector_field, self._dialect)
-            if self._dialect == DIALECT_POSTGRES:
-                op = "<=>" if distance_metric == "cosine" else ("<->" if distance_metric == "euclidean" else "<#>")
-                query = f"SELECT *, ({field_sql} {op} %s::vector) AS distance FROM {self._table_sql}"
-                query_params = [vec_json] + list(params.values())
-                if where_sql:
-                    query += f" WHERE {field_sql} IS NOT NULL AND ({where_sql})"
-                else:
-                    query += f" WHERE {field_sql} IS NOT NULL"
-                query += f" ORDER BY distance ASC LIMIT {take}"
-            else:
-                placeholder = "?"
-                query = f"SELECT TOP ({take}) *, VECTOR_DISTANCE('{distance_metric}', CAST({field_sql} AS VECTOR({dim}, float32)), CAST({placeholder} AS VECTOR({dim}, float32))) AS distance FROM {self._table_sql}{self._nolock}"
-                query_params = [vec_json] + list(params.values())
-                if where_sql:
-                    query += f" WHERE {field_sql} IS NOT NULL AND ({where_sql})"
+        #    SQLite has no vector operators at all, so skip it entirely: building
+        #    the SQL and catching the error would cost work and still end up on the
+        #    in-memory path in step 2.
+        native_rows = None
+        if self._dialect != DIALECT_SQLITE:
+            try:
+                field_sql = _quote(vector_field, self._dialect)
+                if self._dialect == DIALECT_POSTGRES:
+                    op = "<=>" if distance_metric == "cosine" else ("<->" if distance_metric == "euclidean" else "<#>")
+                    query = f"SELECT *, ({field_sql} {op} %s::vector) AS distance FROM {self._table_sql}"
+                    query_params = [vec_json] + list(params.values())
+                    if where_sql:
+                        query += f" WHERE {field_sql} IS NOT NULL AND ({where_sql})"
+                    else:
+                        query += f" WHERE {field_sql} IS NOT NULL"
+                    query += f" ORDER BY distance ASC LIMIT {take}"
                 else:
-                    query += f" WHERE {field_sql} IS NOT NULL"
-                query += " ORDER BY distance ASC"
-
-            native_rows = self._adapter.exec(query, query_params)
-
-
-            if native_rows is not None:
-                return native_rows
-        except Exception:
-            pass
+                    placeholder = "?"
+                    query = f"SELECT TOP ({take}) *, VECTOR_DISTANCE('{distance_metric}', CAST({field_sql} AS VECTOR({dim}, float32)), CAST({placeholder} AS VECTOR({dim}, float32))) AS distance FROM {self._table_sql}{self._nolock}"
+                    query_params = [vec_json] + list(params.values())
+                    if where_sql:
+                        query += f" WHERE {field_sql} IS NOT NULL AND ({where_sql})"
+                    else:
+                        query += f" WHERE {field_sql} IS NOT NULL"
+                    query += " ORDER BY distance ASC"
+
+                native_rows = self._adapter.exec(query, query_params)
+
+                if native_rows is not None:
+                    return native_rows
+            except Exception:
+                pass
 
         # 2. Secondary fallback: In-memory similarity computation if DB engine lacks native vector extension
         rows = self.find_many(where=where)

package/rust/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "an5-adapters"
+version = "0.1.0"
+edition = "2021"
+description = "Standalone database adapter runtime for AN5 ORM (Rust) — connection handling, dialect-aware CRUD, aggregates and vector search."
+license = "MIT"
+repository = "https://github.com/an5ORM/an5Adapters"
+homepage = "https://github.com/an5ORM/an5Adapters/tree/main/rust"
+documentation = "https://docs.rs/an5-adapters"
+readme = "README.md"
+keywords = ["orm", "sql", "database", "postgres", "sqlx"]
+categories = ["database", "database-implementations"]
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+sqlx = { version = "0.8", default-features = false, features = [
+    "any",
+    "runtime-tokio",
+    "json",
+] }
+tokio = { version = "1", features = ["rt"] }
+
+[dev-dependencies]
+tokio = { version = "1", features = ["rt-multi-thread", "macros"] }
+sqlx = { version = "0.8", default-features = false, features = [
+    "any",
+    "runtime-tokio",
+    "json",
+    "sqlite",
+] }