@an5/adapters 0.2.6 → 0.2.9

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",
+] }

package/rust/README.md

@@ -0,0 +1,71 @@
+# an5-adapters
+
+Database adapter runtime for [AN5 ORM](https://github.com/an5ORM/an5) in Rust.
+
+`An5Adapter` owns the connection and the dialect; `TableClient` provides the ORM
+CRUD surface on top of [`sqlx`](https://github.com/launchbadge/sqlx). Dialects are
+detected from the connection string, so SQL Server, PostgreSQL and SQLite are
+handled without configuration. This crate mirrors the TypeScript, Python, .NET
+and Go adapter packages.
+
+## Install
+
+```toml
+[dependencies]
+an5-adapters = "0.1"
+```
+
+The crate is driver-agnostic: it depends on `sqlx` with `any`, so the application
+picks the driver it needs and enables the matching `sqlx` feature.
+
+```toml
+[dependencies]
+sqlx = { version = "0.8", default-features = false, features = ["any", "runtime-tokio", "postgres"] }
+```
+
+## Usage
+
+```rust
+use an5_adapters::{An5Adapter, FindManyArgs};
+use serde_json::json;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    // Register the drivers this binary needs, then hand the URL to the adapter.
+    sqlx::any::install_drivers(&[sqlx::postgres::any::DRIVER])?;
+    let db = An5Adapter::connect("postgres://localhost:5432/mydb").await?;
+
+    // Dynamic access, the Rust equivalent of `db.user` in TypeScript.
+    let users = db
+        .table("User")
+        .find_many(&FindManyArgs {
+            r#where: Some(json!({ "email": { "contains": "@example.com" } })),
+            take: 10,
+            ..Default::default()
+        })
+        .await?;
+
+    println!("{} users", users.len());
+    Ok(())
+}
+```
+
+Generated Rust clients (`an5-client`) wrap this crate and expose one typed handle
+per model — `db.user().find_many(&UserFindManyArgs { .. })` — instead of the
+dynamic `db.table("User")` access shown above.
+
+### Features
+
+- `An5Adapter::connect` / `create_an5_adapter`, with the connection string read
+  from `DATABASE_URL` when omitted
+- Dialect detection and identifier quoting for MSSQL, PostgreSQL and SQLite
+- `TableClient`: `find_many`, `find_first`, `find_unique`, `count`, `create`,
+  `create_many`, `update`, `update_many`, `delete_many`, `upsert`, `aggregate`,
+  `group_by` and `vector_search`
+- Transactions, raw SQL execution and view clients
+- `base` module with the where/order-by builders, adapter metadata and vector
+  distance math
+
+## License
+
+MIT