ns-orm 0.0.0__py3-none-any.whl

ns_orm/dialects.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, Mapping, Optional
+
+from ns_orm.exceptions import ConfigurationError
+
+_PARAM_RE = re.compile(r":([a-zA-Z_]\w*)")
+_DIALECTS: Dict[str, Dialect] = {}
+
+
+@dataclass(frozen=True)
+class PreparedSQL:
+    sql: str
+    params: Any
+
+
+@dataclass(frozen=True)
+class Dialect:
+    name: str
+    paramstyle: str
+    quote_char: str = '"'
+
+    def quote_ident(self, ident: str) -> str:
+        q = self.quote_char
+        escaped = ident.replace(q, q + q)
+        return f"{q}{escaped}{q}"
+
+    def apply_limit_offset(
+        self, sql: str, limit: Optional[int], offset: Optional[int]
+    ) -> str:
+        if limit is None and offset is None:
+            return sql
+        if limit is None:
+            return f"{sql} LIMIT -1 OFFSET {offset}"
+        if offset is None:
+            return f"{sql} LIMIT {limit}"
+        return f"{sql} LIMIT {limit} OFFSET {offset}"
+
+    def prepare(self, sql: str, params: Mapping[str, Any]) -> PreparedSQL:
+        style = self.paramstyle
+        if not params:
+            return PreparedSQL(
+                sql=sql, params=() if style in {"qmark", "format"} else {}
+            )
+
+        keys_in_order = _PARAM_RE.findall(sql)
+        if not keys_in_order:
+            return PreparedSQL(sql=sql, params=params)
+
+        if style == "named":
+            return PreparedSQL(sql=sql, params=dict(params))
+
+        if style == "pyformat":
+            sql2 = _PARAM_RE.sub(lambda m: f"%({m.group(1)})s", sql)
+            return PreparedSQL(sql=sql2, params=dict(params))
+
+        if style == "qmark":
+            sql2 = _PARAM_RE.sub("?", sql)
+            return PreparedSQL(sql=sql2, params=tuple(params[k] for k in keys_in_order))
+
+        if style == "format":
+            sql2 = _PARAM_RE.sub("%s", sql)
+            return PreparedSQL(sql=sql2, params=tuple(params[k] for k in keys_in_order))
+
+        if style == "numeric":
+            mapping: dict[str, int] = {}
+            out_params: list[Any] = []
+
+            def _sub(m: re.Match[str]) -> str:
+                key = m.group(1)
+                if key not in mapping:
+                    mapping[key] = len(out_params) + 1
+                    out_params.append(params[key])
+                return f":{mapping[key]}"
+
+            sql2 = _PARAM_RE.sub(_sub, sql)
+            return PreparedSQL(sql=sql2, params=tuple(out_params))
+
+        raise ConfigurationError(f"Unsupported paramstyle: {style}")
+
+    def type_sql(self, field_def: Any) -> str:
+        render = getattr(field_def, "render_type", None)
+        if callable(render):
+            return str(render(self))
+
+        sa_type = getattr(field_def, "sa_type", None)
+        if sa_type is None:
+            raise ConfigurationError(f"Field has no type: {field_def}")
+
+        if sa_type == "VARCHAR":
+            max_length = getattr(field_def, "max_length", 255)
+            return f"VARCHAR({int(max_length)})"
+        if sa_type == "CHAR":
+            length = getattr(field_def, "length", 1)
+            return f"CHAR({int(length)})"
+        if sa_type == "BINARY":
+            length = getattr(field_def, "length", None)
+            return "BLOB" if length is None else f"BINARY({int(length)})"
+        if sa_type == "DECIMAL":
+            precision = getattr(field_def, "precision", 18)
+            scale = getattr(field_def, "scale", 6)
+            return f"DECIMAL({int(precision)},{int(scale)})"
+        if sa_type in {
+            "TINYINT",
+            "SMALLINT",
+            "INTEGER",
+            "BIGINT",
+            "REAL",
+            "DOUBLE",
+            "FLOAT",
+            "BOOLEAN",
+            "TEXT",
+            "DATE",
+            "JSON",
+            "UUID",
+        }:
+            return sa_type
+        if sa_type == "DATETIME":
+            return "TIMESTAMP"
+
+        return str(sa_type)
+
+    def ddl_create_table(
+        self,
+        *,
+        table_name: str,
+        columns: list[tuple[str, Any]],
+        pk_name: str,
+        fks: list[tuple[str, str, str, str]],
+        uniques: Iterable[str],
+        unique_together: Iterable[tuple[str, ...]] = (),
+    ) -> str:
+        qn = self.quote_ident(table_name)
+        col_sql: list[str] = []
+        for name, fdef in columns:
+            parts = [self.quote_ident(name), self.type_sql(fdef)]
+            if getattr(fdef, "primary_key", False):
+                parts.append("PRIMARY KEY")
+            nullable = getattr(fdef, "nullable", None)
+            if nullable is False:
+                parts.append("NOT NULL")
+            if getattr(fdef, "unique", False):
+                parts.append("UNIQUE")
+            col_sql.append(" ".join(parts))
+
+        for from_col, to_table, to_col, on_delete in fks:
+            col_sql.append(
+                " ".join(
+                    [
+                        "FOREIGN KEY",
+                        f"({self.quote_ident(from_col)})",
+                        "REFERENCES",
+                        f"{self.quote_ident(to_table)}({self.quote_ident(to_col)})",
+                        "ON DELETE",
+                        on_delete,
+                    ]
+                )
+            )
+
+        for col in uniques:
+            col_sql.append(f"UNIQUE ({self.quote_ident(col)})")
+
+        for cols in unique_together:
+            col_sql.append(
+                "UNIQUE (" + ", ".join(self.quote_ident(c) for c in cols) + ")"
+            )
+
+        return f"CREATE TABLE IF NOT EXISTS {qn} (\n  " + ",\n  ".join(col_sql) + "\n)"
+
+
+@dataclass(frozen=True)
+class ClickHouseDialect(Dialect):
+    def type_sql(self, field_def: Any) -> str:
+        render = getattr(field_def, "render_type", None)
+        if callable(render):
+            return str(render(self))
+
+        sa_type = getattr(field_def, "sa_type", None)
+        if sa_type is None:
+            raise ConfigurationError(f"Field has no type: {field_def}")
+
+        mapping = {
+            "TINYINT": "Int8",
+            "SMALLINT": "Int16",
+            "INTEGER": "Int32",
+            "BIGINT": "Int64",
+            "UTINYINT": "UInt8",
+            "USMALLINT": "UInt16",
+            "UINTEGER": "UInt32",
+            "UBIGINT": "UInt64",
+            "FLOAT": "Float32",
+            "REAL": "Float32",
+            "DOUBLE": "Float64",
+            "BOOLEAN": "Bool",
+            "TEXT": "String",
+            "VARCHAR": "String",
+            "CHAR": "String",
+            "DATE": "Date",
+            "DATETIME": "DateTime",
+            "UUID": "UUID",
+            "JSON": "JSON",
+        }
+        if sa_type == "DECIMAL":
+            precision = getattr(field_def, "precision", 18)
+            scale = getattr(field_def, "scale", 6)
+            return f"Decimal({int(precision)},{int(scale)})"
+        return mapping.get(str(sa_type), str(sa_type))
+
+    def ddl_create_table(
+        self,
+        *,
+        table_name: str,
+        columns: list[tuple[str, Any]],
+        pk_name: str,
+        fks: list[tuple[str, str, str, str]],
+        uniques: Iterable[str],
+        unique_together: Iterable[tuple[str, ...]] = (),
+    ) -> str:
+        qn = self.quote_ident(table_name)
+        col_sql: list[str] = []
+        for name, fdef in columns:
+            parts = [self.quote_ident(name), self.type_sql(fdef)]
+            nullable = getattr(fdef, "nullable", None)
+            if nullable is False:
+                parts.append("NOT NULL")
+            col_sql.append(" ".join(parts))
+
+        columns_ddl = ",\n  ".join(col_sql)
+        return (
+            f"CREATE TABLE IF NOT EXISTS {qn} (\n  {columns_ddl}\n)"
+            " ENGINE = MergeTree() ORDER BY tuple()"
+        )
+
+
+SQLITE_DIALECT = Dialect(name="sqlite", paramstyle="qmark", quote_char='"')
+POSTGRES_DIALECT = Dialect(name="postgres", paramstyle="pyformat", quote_char='"')
+MYSQL_DIALECT = Dialect(name="mysql", paramstyle="pyformat", quote_char="`")
+MSSQL_DIALECT = Dialect(name="mssql", paramstyle="qmark", quote_char='"')
+ORACLE_DIALECT = Dialect(name="oracle", paramstyle="named", quote_char='"')
+DUCKDB_DIALECT = Dialect(name="duckdb", paramstyle="qmark", quote_char='"')
+CLICKHOUSE_DIALECT = ClickHouseDialect(
+    name="clickhouse", paramstyle="pyformat", quote_char="`"
+)
+
+_DIALECTS.update(
+    {
+        "sqlite": SQLITE_DIALECT,
+        "postgres": POSTGRES_DIALECT,
+        "postgresql": POSTGRES_DIALECT,
+        "mysql": MYSQL_DIALECT,
+        "mssql": MSSQL_DIALECT,
+        "sqlserver": MSSQL_DIALECT,
+        "oracle": ORACLE_DIALECT,
+        "duckdb": DUCKDB_DIALECT,
+        "clickhouse": CLICKHOUSE_DIALECT,
+        "ch": CLICKHOUSE_DIALECT,
+    }
+)
+
+
+def register_dialect(name: str, dialect: Dialect) -> None:
+    _DIALECTS[name.lower()] = dialect
+
+
+def get_dialect(name: str) -> Dialect:
+    key = name.lower()
+    if key in _DIALECTS:
+        return _DIALECTS[key]
+    return Dialect(name=key, paramstyle="named", quote_char='"')
+
+
+def _normalize_scheme(scheme: str) -> str:
+    scheme = scheme.strip().lower()
+    if "+" in scheme:
+        scheme = scheme.split("+", 1)[0]
+    return scheme
+
+
+def dialect_from_url(scheme: str) -> Dialect:
+    scheme = _normalize_scheme(scheme)
+    if scheme.startswith(("mariadb", "tidb")):
+        scheme = "mysql"
+    if scheme.startswith(("cockroachdb", "redshift")):
+        scheme = "postgres"
+    for key, d in _DIALECTS.items():
+        if scheme.startswith(key):
+            return d
+    return get_dialect(scheme)

ns_orm/exceptions.py

@@ -0,0 +1,26 @@
+class OrmError(Exception):
+    pass
+
+
+class ConfigurationError(OrmError):
+    pass
+
+
+class ModelDefinitionError(OrmError):
+    pass
+
+
+class QueryError(OrmError):
+    pass
+
+
+class DoesNotExist(OrmError):
+    pass
+
+
+class MultipleObjectsReturned(OrmError):
+    pass
+
+
+class IntegrityError(OrmError):
+    pass

ns_orm/expressions.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Iterable, List, Mapping, Tuple, Union
+
+
+@dataclass(frozen=True)
+class Condition:
+    sql: str
+    params: Mapping[str, Any]
+
+
+def _merge_params(*parts: Mapping[str, Any]) -> dict[str, Any]:
+    merged: dict[str, Any] = {}
+    for p in parts:
+        for k, v in p.items():
+            if k in merged:
+                raise ValueError(f"Duplicate param: {k}")
+            merged[k] = v
+    return merged
+
+
+class Q:
+    __slots__ = ("_op", "_children", "_negated")
+
+    def __init__(self, **lookups: Any):
+        self._op: str = "AND"
+        self._children: List[Union[Q, Tuple[str, Any]]] = []
+        self._negated: bool = False
+        for k, v in lookups.items():
+            self._children.append((k, v))
+
+    def __and__(self, other: Q) -> Q:
+        return self._combine("AND", other)
+
+    def __or__(self, other: Q) -> Q:
+        return self._combine("OR", other)
+
+    def __invert__(self) -> Q:
+        q = Q()
+        q._op = self._op
+        q._children = list(self._children)
+        q._negated = not self._negated
+        return q
+
+    def _combine(self, op: str, other: Q) -> Q:
+        q = Q()
+        q._op = op
+        q._children = [self, other]
+        return q
+
+    def is_empty(self) -> bool:
+        return not self._children
+
+    def compile(
+        self,
+        *,
+        table_alias: str,
+        param_prefix: str,
+        start_index: int,
+        lookup_compiler: Any,
+    ) -> tuple[Condition, int]:
+        if self.is_empty():
+            return Condition(sql="1=1", params={}), start_index
+
+        parts: list[str] = []
+        params: dict[str, Any] = {}
+        idx = start_index
+
+        for child in self._children:
+            if isinstance(child, Q):
+                cond, idx = child.compile(
+                    table_alias=table_alias,
+                    param_prefix=param_prefix,
+                    start_index=idx,
+                    lookup_compiler=lookup_compiler,
+                )
+                parts.append(f"({cond.sql})")
+                params = _merge_params(params, cond.params)
+                continue
+
+            lookup, value = child
+            cond, idx = lookup_compiler(
+                lookup=lookup,
+                value=value,
+                table_alias=table_alias,
+                param_prefix=param_prefix,
+                start_index=idx,
+            )
+            parts.append(cond.sql)
+            params = _merge_params(params, cond.params)
+
+        combined = f" {self._op} ".join(parts)
+        if self._negated:
+            combined = f"NOT ({combined})"
+        return Condition(sql=combined, params=params), idx
+
+
+def normalize_in_values(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    if isinstance(value, (str, bytes)):
+        return [value]
+    if isinstance(value, Mapping):
+        return list(value.values())
+    if isinstance(value, Iterable):
+        return list(value)
+    return [value]