@an5/adapters 0.2.5 → 0.2.9

package/python/base/sql.py

@@ -1,121 +1,202 @@
-from typing import Any, Dict, List, Optional
-from .dialects import DIALECT_MSSQL, DIALECT_POSTGRES
-from .metadata import model_to_table, model_fields
-
-# ─── Quoting ───────────────────────────────────────────────────────────────────────
-
-def _quote(name: str, dialect: str) -> str:
-    if dialect == DIALECT_POSTGRES:
-        if name.startswith("[") and name.endswith("]"):
-            return f'"{name[1:-1]}"'
-        return f'"{name}"'
-    return name if name.startswith("[") else f"[{name}]"
-
-
-# ─── Connection helpers live in provider modules ────────────────────────────────
-
-# ─── Where clause builder ──────────────────────────────────────────────────────────
-
-def _parse_where(model_name: str, where: Optional[Dict], params: Dict, dialect: str, prefix: str = "") -> str:
-    if not where:
-        return ""
-    conditions: List[str] = []
-
-    for key, value in 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)})")
-        elif key == "AND" and isinstance(value, list):
-            sub = [_parse_where(model_name, v, params, dialect, f"{prefix}and{i}_") for i, v in enumerate(value)]
-            sub = [s for s in sub if s]
-            if sub:
-                conditions.append(f"({' AND '.join(sub)})")
-        else:
-            col = _quote(key, dialect)
-            pname = f"{prefix}{key}"
-            placeholder = "%s" if dialect == DIALECT_POSTGRES else "?"
-            if value is None:
-                conditions.append(f"{col} IS NULL")
-            elif isinstance(value, dict):
-                if "not" in value:
-                    if value["not"] is None:
-                        conditions.append(f"{col} IS NOT NULL")
-                    else:
-                        params[f"{pname}_not"] = value["not"]
-                        conditions.append(f"{col} <> {placeholder}")
-                if "equals" in value:
-                    params[f"{pname}_eq"] = value["equals"]
-                    conditions.append(f"{col} = {placeholder}")
-                if "contains" in value:
-                    params[f"{pname}_co"] = f"%{value['contains']}%"
-                    conditions.append(f"{col} LIKE {placeholder}")
-                if "startsWith" in value:
-                    params[f"{pname}_sw"] = f"{value['startsWith']}%"
-                    conditions.append(f"{col} LIKE {placeholder}")
-                if "endsWith" in value:
-                    params[f"{pname}_ew"] = f"%{value['endsWith']}"
-                    conditions.append(f"{col} LIKE {placeholder}")
-                if "gte" in value:
-                    params[f"{pname}_gte"] = value["gte"]
-                    conditions.append(f"{col} >= {placeholder}")
-                if "lte" in value:
-                    params[f"{pname}_lte"] = value["lte"]
-                    conditions.append(f"{col} <= {placeholder}")
-                if "gt" in value:
-                    params[f"{pname}_gt"] = value["gt"]
-                    conditions.append(f"{col} > {placeholder}")
-                if "lt" in value:
-                    params[f"{pname}_lt"] = value["lt"]
-                    conditions.append(f"{col} < {placeholder}")
-                if "in" in value:
-                    vals = value["in"]
-                    if vals:
-                        placeholders = ", ".join([placeholder] * len(vals))
-                        for i, v in enumerate(vals):
-                            params[f"{pname}_in{i}"] = v
-                        conditions.append(f"{col} IN ({placeholders})")
-                    else:
-                        conditions.append("1=0")
-            else:
-                params[pname] = value
-                conditions.append(f"{col} = {placeholder}")
-
-    return " AND ".join(conditions)
-
-
-def _build_order_by(order_by: Any, dialect: str) -> str:
-    if not order_by:
-        return ""
-    entries = order_by if isinstance(order_by, list) else [order_by]
-    parts: List[str] = []
-    for entry in entries:
-        for col, direction in entry.items():
-            parts.append(f"{_quote(col, dialect)} {str(direction).upper()}")
-    return f"ORDER BY {', '.join(parts)}" if parts else ""
-
-
-# ─── 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]
-    return model_name
-
-
-def _quote_table(t: str, dialect: str) -> str:
-    q = lambda s: f'"{s}"' if dialect == DIALECT_POSTGRES else f"[{s}]"
-    if t.startswith("[") or t.startswith('"'):
-        return t
-    if "." in t:
-        return ".".join(q(p) for p in t.split("."))
-    return q(t)
-
-
+from typing import Any, Dict, List, Optional
+from .dialects import DIALECT_MSSQL, DIALECT_POSTGRES, DIALECT_SQLITE
+from .metadata import model_to_table, model_fields, resolve_model_key
+
+# ─── Quoting ───────────────────────────────────────────────────────────────────────
+
+def _strip_wrapping(name: str, left: str, right: str) -> str:
+    return name[len(left):-len(right)] if name.startswith(left) and name.endswith(right) else name
+
+
+def _quote(name: str, dialect: str) -> str:
+    raw = str(name)
+    if dialect in (DIALECT_POSTGRES, DIALECT_SQLITE):
+        unwrapped = _strip_wrapping(_strip_wrapping(raw, "[", "]"), '"', '"')
+        return f'"{unwrapped.replace(chr(34), chr(34) * 2)}"'
+    unwrapped = _strip_wrapping(raw, "[", "]")
+    return f"[{unwrapped.replace(']', ']]')}]"
+
+
+def _sanitize_param_name(name: str) -> str:
+    cleaned = "".join(ch if ch.isalnum() or ch == "_" else "_" for ch in str(name))
+    return cleaned if cleaned[:1].isalpha() else f"p_{cleaned}"
+
+
+def _normalize_sort_direction(direction: Any) -> str:
+    return "DESC" if isinstance(direction, str) and direction.upper() == "DESC" else "ASC"
+
+
+# ─── Connection helpers live in provider modules ────────────────────────────────
+
+# ─── Where clause builder ──────────────────────────────────────────────────────────
+
+_OPERATOR_KEYS = {"equals", "in", "notIn", "contains", "startsWith", "endsWith", "not", "gte", "lte", "gt", "lt"}
+
+
+def _is_operator_value(value: Any) -> bool:
+    return isinstance(value, dict) and any(op in value for op in _OPERATOR_KEYS)
+
+
+def _parse_where(model_name: str, where: Optional[Dict], params: Dict, dialect: str, prefix: str = "") -> str:
+    if not where:
+        return ""
+    conditions: List[str] = []
+
+    clean_where: Dict[str, Any] = {}
+    for key, value in where.items():
+        if "_" in key and isinstance(value, dict) and not _is_operator_value(value):
+            clean_where.update(value)
+        else:
+            clean_where[key] = value
+
+    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)})")
+        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)]
+            sub = [s for s in sub if s]
+            if sub:
+                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]
+            if sub:
+                conditions.append(f"NOT ({' AND '.join(sub)})")
+        else:
+            col = _quote(key, dialect)
+            pname = _sanitize_param_name(f"{prefix}{key}")
+            placeholder = "%s" if dialect == DIALECT_POSTGRES else "?"
+            if value is None:
+                conditions.append(f"{col} IS NULL")
+            elif isinstance(value, dict):
+                if "not" in value:
+                    if value["not"] is None:
+                        conditions.append(f"{col} IS NOT NULL")
+                    elif isinstance(value["not"], dict):
+                        nested_params: Dict[str, Any] = {}
+                        nested_sql = _parse_where(model_name, {key: value["not"]}, nested_params, dialect, f"{prefix}{key}_not_")
+                        params.update(nested_params)
+                        if nested_sql:
+                            conditions.append(f"NOT ({nested_sql})")
+                    else:
+                        params[f"{pname}_not"] = value["not"]
+                        conditions.append(f"{col} <> {placeholder}")
+                if "equals" in value:
+                    if value["equals"] is None:
+                        conditions.append(f"{col} IS NULL")
+                    else:
+                        params[f"{pname}_eq"] = value["equals"]
+                        conditions.append(f"{col} = {placeholder}")
+                if "contains" in value:
+                    params[f"{pname}_co"] = f"%{value['contains']}%"
+                    conditions.append(f"{col} LIKE {placeholder}")
+                if "startsWith" in value:
+                    params[f"{pname}_sw"] = f"{value['startsWith']}%"
+                    conditions.append(f"{col} LIKE {placeholder}")
+                if "endsWith" in value:
+                    params[f"{pname}_ew"] = f"%{value['endsWith']}"
+                    conditions.append(f"{col} LIKE {placeholder}")
+                if "gte" in value:
+                    params[f"{pname}_gte"] = value["gte"]
+                    conditions.append(f"{col} >= {placeholder}")
+                if "lte" in value:
+                    params[f"{pname}_lte"] = value["lte"]
+                    conditions.append(f"{col} <= {placeholder}")
+                if "gt" in value:
+                    params[f"{pname}_gt"] = value["gt"]
+                    conditions.append(f"{col} > {placeholder}")
+                if "lt" in value:
+                    params[f"{pname}_lt"] = value["lt"]
+                    conditions.append(f"{col} < {placeholder}")
+                if "in" in value:
+                    vals = value["in"]
+                    if vals:
+                        placeholders = ", ".join([placeholder] * len(vals))
+                        for i, v in enumerate(vals):
+                            params[f"{pname}_in{i}"] = v
+                        conditions.append(f"{col} IN ({placeholders})")
+                    else:
+                        conditions.append("1=0")
+                if "notIn" in value:
+                    vals = value["notIn"]
+                    if vals:
+                        placeholders = ", ".join([placeholder] * len(vals))
+                        for i, v in enumerate(vals):
+                            params[f"{pname}_notin{i}"] = v
+                        conditions.append(f"{col} NOT IN ({placeholders})")
+                    else:
+                        conditions.append("1=1")
+            else:
+                params[pname] = value
+                conditions.append(f"{col} = {placeholder}")
+
+    return " AND ".join(conditions)
+
+
+def _build_order_by(order_by: Any, dialect: str) -> str:
+    if not order_by:
+        return ""
+    entries = order_by if isinstance(order_by, list) else [order_by]
+    parts: List[str] = []
+    for entry in entries:
+        for col, direction in entry.items():
+            parts.append(f"{_quote(col, dialect)} {_normalize_sort_direction(direction)}")
+    return f"ORDER BY {', '.join(parts)}" if parts else ""
+
+
+# ─── Table name resolution ─────────────────────────────────────────────────────────
+
+def _resolve_table(model_name: str) -> str:
+    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:
+    # 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/mssql/__init__.py

@@ -1 +1 @@
-from .provider import PYODBC_AVAILABLE, connect, parse_connection_string, placeholder
+from .provider import PYODBC_AVAILABLE, connect, parse_connection_string, placeholder

package/python/mssql/provider.py

@@ -1,62 +1,62 @@
-try:
-    import pyodbc
-    PYODBC_AVAILABLE = True
-except ImportError:
-    pyodbc = None
-    PYODBC_AVAILABLE = False
-
-def parse_connection_string(url: str) -> str:
-    """Convert sqlserver:// URL to pyodbc connection string."""
-    url = url.replace("sqlserver://", "")
-    parts = url.split(";")
-    host_part = parts[0]
-    host, _, port = host_part.partition(":")
-    port = port or "1433"
-
-    config: Dict[str, str] = {"server": host, "port": port}
-    for part in parts[1:]:
-        if "=" not in part:
-            continue
-        k, _, v = part.partition("=")
-        k = k.strip().lower()
-        v = v.strip()
-        if k in ("database",):
-            config["database"] = v
-        elif k in ("user", "uid"):
-            config["user"] = v
-        elif k in ("password", "pwd"):
-            config["password"] = v
-        elif k == "encrypt":
-            config["encrypt"] = "yes" if v.lower() == "true" else "no"
-        elif k == "trustservercertificate":
-            config["trust"] = "yes" if v.lower() == "true" else "no"
-
-    encrypt = config.get("encrypt", "yes")
-    trust = config.get("trust", "yes")
-    if "user" in config:
-        return (
-            f"DRIVER={{ODBC Driver 17 for SQL Server}};"
-            f"SERVER={config['server']},{config['port']};"
-            f"DATABASE={config.get('database', '')};"
-            f"UID={config['user']};"
-            f"PWD={config.get('password', '')};"
-            f"Encrypt={encrypt};TrustServerCertificate={trust};"
-        )
-    # Windows auth
-    return (
-        f"DRIVER={{ODBC Driver 17 for SQL Server}};"
-        f"SERVER={config['server']},{config['port']};"
-        f"DATABASE={config.get('database', '')};"
-        f"Trusted_Connection=yes;"
-        f"Encrypt={encrypt};TrustServerCertificate={trust};"
-    )
-
-
-
-def connect(connection_string: str):
-    if not PYODBC_AVAILABLE:
-        raise ImportError("pyodbc is required: pip install pyodbc")
-    return pyodbc.connect(parse_connection_string(connection_string), autocommit=True)
-
-def placeholder() -> str:
-    return "?"
+try:
+    import pyodbc
+    PYODBC_AVAILABLE = True
+except ImportError:
+    pyodbc = None
+    PYODBC_AVAILABLE = False
+
+def parse_connection_string(url: str) -> str:
+    """Convert sqlserver:// URL to pyodbc connection string."""
+    url = url.replace("sqlserver://", "")
+    parts = url.split(";")
+    host_part = parts[0]
+    host, _, port = host_part.partition(":")
+    port = port or "1433"
+
+    config: Dict[str, str] = {"server": host, "port": port}
+    for part in parts[1:]:
+        if "=" not in part:
+            continue
+        k, _, v = part.partition("=")
+        k = k.strip().lower()
+        v = v.strip()
+        if k in ("database",):
+            config["database"] = v
+        elif k in ("user", "uid"):
+            config["user"] = v
+        elif k in ("password", "pwd"):
+            config["password"] = v
+        elif k == "encrypt":
+            config["encrypt"] = "yes" if v.lower() == "true" else "no"
+        elif k == "trustservercertificate":
+            config["trust"] = "yes" if v.lower() == "true" else "no"
+
+    encrypt = config.get("encrypt", "yes")
+    trust = config.get("trust", "yes")
+    if "user" in config:
+        return (
+            f"DRIVER={{ODBC Driver 17 for SQL Server}};"
+            f"SERVER={config['server']},{config['port']};"
+            f"DATABASE={config.get('database', '')};"
+            f"UID={config['user']};"
+            f"PWD={config.get('password', '')};"
+            f"Encrypt={encrypt};TrustServerCertificate={trust};"
+        )
+    # Windows auth
+    return (
+        f"DRIVER={{ODBC Driver 17 for SQL Server}};"
+        f"SERVER={config['server']},{config['port']};"
+        f"DATABASE={config.get('database', '')};"
+        f"Trusted_Connection=yes;"
+        f"Encrypt={encrypt};TrustServerCertificate={trust};"
+    )
+
+
+
+def connect(connection_string: str):
+    if not PYODBC_AVAILABLE:
+        raise ImportError("pyodbc is required: pip install pyodbc")
+    return pyodbc.connect(parse_connection_string(connection_string), autocommit=True)
+
+def placeholder() -> str:
+    return "?"

package/python/postgres/__init__.py

@@ -1 +1 @@
-from .provider import PSYCOPG2_AVAILABLE, connect, placeholder
+from .provider import PSYCOPG2_AVAILABLE, connect, placeholder

package/python/postgres/provider.py

@@ -1,15 +1,15 @@
-try:
-    import psycopg2
-    import psycopg2.extras
-    PSYCOPG2_AVAILABLE = True
-except ImportError:
-    psycopg2 = None
-    PSYCOPG2_AVAILABLE = False
-
-def connect(connection_string: str):
-    if not PSYCOPG2_AVAILABLE:
-        raise ImportError("psycopg2 is required: pip install psycopg2-binary")
-    return psycopg2.connect(connection_string)
-
-def placeholder() -> str:
-    return "%s"
+try:
+    import psycopg2
+    import psycopg2.extras
+    PSYCOPG2_AVAILABLE = True
+except ImportError:
+    psycopg2 = None
+    PSYCOPG2_AVAILABLE = False
+
+def connect(connection_string: str):
+    if not PSYCOPG2_AVAILABLE:
+        raise ImportError("psycopg2 is required: pip install psycopg2-binary")
+    return psycopg2.connect(connection_string)
+
+def placeholder() -> str:
+    return "%s"

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 "?"