ns-orm 0.0.0__py3-none-any.whl

ns_orm/fields.py

@@ -0,0 +1,313 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Type, Union
+
+from typing_extensions import Literal
+
+
+@dataclass(frozen=True)
+class FieldDef:
+    primary_key: bool = False
+    nullable: Optional[bool] = None
+    unique: bool = False
+    index: bool = False
+    default: Any = None
+    server_default: Any = None
+    autoincrement: Optional[bool] = None
+
+    def ddl(self) -> dict[str, Any]:
+        return {
+            "primary_key": self.primary_key,
+            "nullable": self.nullable,
+            "unique": self.unique,
+            "index": self.index,
+            "default": self.default,
+            "server_default": self.server_default,
+            "autoincrement": self.autoincrement,
+        }
+
+
+@dataclass(frozen=True)
+class ColumnField(FieldDef):
+    sa_type: Any = None
+
+
+@dataclass(frozen=True)
+class TinyInt(ColumnField):
+    sa_type: Any = "TINYINT"
+
+
+@dataclass(frozen=True)
+class SmallInt(ColumnField):
+    sa_type: Any = "SMALLINT"
+
+
+@dataclass(frozen=True)
+class Int(ColumnField):
+    sa_type: Any = "INTEGER"
+
+
+@dataclass(frozen=True)
+class BigInt(ColumnField):
+    sa_type: Any = "BIGINT"
+
+
+@dataclass(frozen=True)
+class UTinyInt(ColumnField):
+    sa_type: Any = "UTINYINT"
+
+
+@dataclass(frozen=True)
+class USmallInt(ColumnField):
+    sa_type: Any = "USMALLINT"
+
+
+@dataclass(frozen=True)
+class UInt(ColumnField):
+    sa_type: Any = "UINTEGER"
+
+
+@dataclass(frozen=True)
+class UBigInt(ColumnField):
+    sa_type: Any = "UBIGINT"
+
+
+@dataclass(frozen=True)
+class Float(ColumnField):
+    sa_type: Any = "FLOAT"
+
+
+@dataclass(frozen=True)
+class Real(ColumnField):
+    sa_type: Any = "REAL"
+
+
+@dataclass(frozen=True)
+class Double(ColumnField):
+    sa_type: Any = "DOUBLE"
+
+
+@dataclass(frozen=True)
+class Decimal(ColumnField):
+    precision: int = 18
+    scale: int = 6
+    sa_type: Any = "DECIMAL"
+
+
+@dataclass(frozen=True)
+class Boolean(ColumnField):
+    sa_type: Any = "BOOLEAN"
+
+
+@dataclass(frozen=True)
+class Char(ColumnField):
+    length: int = 1
+    sa_type: Any = "CHAR"
+
+
+@dataclass(frozen=True)
+class String(ColumnField):
+    max_length: int = 255
+    sa_type: Any = "VARCHAR"
+
+
+@dataclass(frozen=True)
+class Text(ColumnField):
+    sa_type: Any = "TEXT"
+
+
+@dataclass(frozen=True)
+class Binary(ColumnField):
+    length: Optional[int] = None
+    sa_type: Any = "BINARY"
+
+
+@dataclass(frozen=True)
+class DateTime(ColumnField):
+    timezone: bool = False
+    sa_type: Any = "DATETIME"
+
+
+@dataclass(frozen=True)
+class Date(ColumnField):
+    sa_type: Any = "DATE"
+
+
+@dataclass(frozen=True)
+class JSON(ColumnField):
+    sa_type: Any = "JSON"
+
+
+@dataclass(frozen=True)
+class UUID(ColumnField):
+    sa_type: Any = "UUID"
+
+
+@dataclass(frozen=True)
+class IPv4(ColumnField):
+    sa_type: Any = "IPv4"
+
+    def render_type(self, dialect: Any) -> str:
+        if getattr(dialect, "name", "") == "clickhouse":
+            return "IPv4"
+        return "VARCHAR(15)"
+
+
+@dataclass(frozen=True)
+class IPv6(ColumnField):
+    sa_type: Any = "IPv6"
+
+    def render_type(self, dialect: Any) -> str:
+        if getattr(dialect, "name", "") == "clickhouse":
+            return "IPv6"
+        return "VARCHAR(39)"
+
+
+@dataclass(frozen=True)
+class Date32(ColumnField):
+    sa_type: Any = "Date32"
+
+    def render_type(self, dialect: Any) -> str:
+        if getattr(dialect, "name", "") == "clickhouse":
+            return "Date32"
+        return "DATE"
+
+
+@dataclass(frozen=True)
+class DateTime64(ColumnField):
+    precision: int = 3
+    timezone: Optional[str] = None
+    sa_type: Any = "DateTime64"
+
+    def render_type(self, dialect: Any) -> str:
+        if getattr(dialect, "name", "") == "clickhouse":
+            if self.timezone:
+                return f"DateTime64({int(self.precision)}, '{self.timezone}')"
+            return f"DateTime64({int(self.precision)})"
+        return "TIMESTAMP"
+
+
+@dataclass(frozen=True)
+class FixedString(ColumnField):
+    length: int = 16
+    sa_type: Any = "FixedString"
+
+    def render_type(self, dialect: Any) -> str:
+        if getattr(dialect, "name", "") == "clickhouse":
+            return f"FixedString({int(self.length)})"
+        return f"VARCHAR({int(self.length)})"
+
+
+@dataclass(frozen=True)
+class Enum8(ColumnField):
+    values: Dict[str, int] = field(default_factory=dict)
+    sa_type: Any = "Enum8"
+
+    def render_type(self, dialect: Any) -> str:
+        if getattr(dialect, "name", "") != "clickhouse":
+            return "VARCHAR(255)"
+        items = ", ".join(f"'{k}' = {int(v)}" for k, v in self.values.items())
+        return f"Enum8({items})"
+
+
+@dataclass(frozen=True)
+class Enum16(ColumnField):
+    values: Dict[str, int] = field(default_factory=dict)
+    sa_type: Any = "Enum16"
+
+    def render_type(self, dialect: Any) -> str:
+        if getattr(dialect, "name", "") != "clickhouse":
+            return "VARCHAR(255)"
+        items = ", ".join(f"'{k}' = {int(v)}" for k, v in self.values.items())
+        return f"Enum16({items})"
+
+
+@dataclass(frozen=True)
+class Array(ColumnField):
+    item: Any = None
+    sa_type: Any = "Array"
+
+    def render_type(self, dialect: Any) -> str:
+        if self.item is None:
+            return (
+                "Array(String)"
+                if getattr(dialect, "name", "") == "clickhouse"
+                else "TEXT"
+            )
+        inner = dialect.type_sql(self.item)
+        if getattr(dialect, "name", "") == "clickhouse":
+            return f"Array({inner})"
+        return "TEXT"
+
+
+@dataclass(frozen=True)
+class Map(ColumnField):
+    key: Any = None
+    value: Any = None
+    sa_type: Any = "Map"
+
+    def render_type(self, dialect: Any) -> str:
+        if getattr(dialect, "name", "") == "clickhouse":
+            k = "String" if self.key is None else dialect.type_sql(self.key)
+            v = "String" if self.value is None else dialect.type_sql(self.value)
+            return f"Map({k}, {v})"
+        return "JSON"
+
+
+@dataclass(frozen=True)
+class TupleType(ColumnField):
+    items: List[Any] = field(default_factory=list)
+    sa_type: Any = "Tuple"
+
+    def render_type(self, dialect: Any) -> str:
+        if getattr(dialect, "name", "") == "clickhouse":
+            inner = ", ".join(dialect.type_sql(i) for i in self.items) or "String"
+            return f"Tuple({inner})"
+        return "TEXT"
+
+
+@dataclass(frozen=True)
+class LowCardinality(ColumnField):
+    inner: Any = None
+    sa_type: Any = "LowCardinality"
+
+    def render_type(self, dialect: Any) -> str:
+        inner = "String" if self.inner is None else dialect.type_sql(self.inner)
+        if getattr(dialect, "name", "") == "clickhouse":
+            return f"LowCardinality({inner})"
+        return inner
+
+
+@dataclass(frozen=True)
+class Nullable(ColumnField):
+    inner: Any = None
+    sa_type: Any = "Nullable"
+
+    def render_type(self, dialect: Any) -> str:
+        inner = "String" if self.inner is None else dialect.type_sql(self.inner)
+        if getattr(dialect, "name", "") == "clickhouse":
+            return f"Nullable({inner})"
+        return inner
+
+
+@dataclass(frozen=True)
+class ForeignKey(FieldDef):
+    to: Union[str, Type[Any]]
+    to_field: str = "id"
+    on_delete: Literal["RESTRICT", "CASCADE", "SET NULL"] = "RESTRICT"
+
+
+@dataclass(frozen=True)
+class OneToOne(ForeignKey):
+    unique: bool = True
+
+
+@dataclass(frozen=True)
+class ManyToMany:
+    to: Union[str, Type[Any]]
+    through: Optional[str] = None
+    from_field: Optional[str] = None
+    to_field: Optional[str] = None
+    related_name: Optional[str] = None
+    extra: dict[str, Any] = field(default_factory=dict)

ns_orm/manager.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVar
+
+from ns_orm.database import AsyncDatabase, Database, get_connection
+from ns_orm.query import AsyncQuerySet, QuerySet
+
+TModel = TypeVar("TModel")
+
+
+@dataclass
+class Manager(Generic[TModel]):
+    model: type[TModel]
+    db: Any = None
+
+    def using(self, db: Any) -> Manager[TModel]:
+        if isinstance(db, str):
+            return Manager(model=self.model, db=get_connection(db))
+        return Manager(model=self.model, db=db)
+
+    def _get_db(self) -> Any:
+        if self.db is not None:
+            return self.db
+        connect_name = getattr(getattr(self.model, "_meta", None), "connect_name", None)
+        if not connect_name:
+            raise ValueError(
+                "Database is not set and Model.Meta.connect_name is missing"
+            )
+        return get_connection(connect_name)
+
+    def qs(self) -> QuerySet[TModel]:
+        db = self._get_db()
+        if not isinstance(db, Database):
+            raise ValueError("Database instance required for sync operations")
+        return QuerySet(self.model, db=db)
+
+    def aqs(self) -> AsyncQuerySet[TModel]:
+        db = self._get_db()
+        if not isinstance(db, AsyncDatabase):
+            raise ValueError("AsyncDatabase instance required for async operations")
+        return AsyncQuerySet(self.model, db=db)
+
+    def all(self) -> list[TModel]:
+        return self.qs().all()
+
+    async def aall(self) -> list[TModel]:
+        return await self.aqs().all()
+
+    def filter(self, **lookups: Any) -> Any:
+        db = self._get_db()
+        if isinstance(db, AsyncDatabase):
+            return self.aqs().filter(**lookups)
+        return self.qs().filter(**lookups)
+
+    def exclude(self, **lookups: Any) -> Any:
+        db = self._get_db()
+        if isinstance(db, AsyncDatabase):
+            return self.aqs().exclude(**lookups)
+        return self.qs().exclude(**lookups)
+
+    def get(self, **lookups: Any) -> TModel:
+        return self.qs().get(**lookups)
+
+    async def aget(self, **lookups: Any) -> TModel:
+        return await self.aqs().get(**lookups)
+
+    def create(self, **data: Any) -> TModel:
+        return self.qs().create(**data)
+
+    async def acreate(self, **data: Any) -> TModel:
+        return await self.aqs().create(**data)

ns_orm/migrations/__init__.py

@@ -0,0 +1,3 @@
+from ns_orm.migrations.migration import Migration
+
+__all__ = ["Migration"]

ns_orm/migrations/autodetector.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from typing import Any, Optional
+
+from ns_orm.dialects import Dialect
+from ns_orm.migrations.migration import Migration
+from ns_orm.migrations.operations import (
+    AddColumn,
+    CreateTable,
+    DropColumn,
+    DropTable,
+    Operation,
+)
+from ns_orm.migrations.state import project_state
+from ns_orm.model import Model
+
+
+def _slug(value: str) -> str:
+    value = value.strip().lower()
+    value = re.sub(r"[^a-z0-9_]+", "_", value)
+    value = re.sub(r"_+", "_", value).strip("_")
+    return value or "auto"
+
+
+def autodetect_migration(
+    *,
+    models: list[type[Any]],
+    dialect: Dialect,
+    previous_state: Optional[dict[str, Any]],
+    name_suffix: str,
+) -> Optional[Migration]:
+    prev = previous_state or {}
+    curr = project_state(models)
+
+    ops: list[Operation] = []
+    for model_name, mstate in curr.items():
+        if model_name not in prev:
+            ops.extend(_ops_create_model(mstate))
+            continue
+        ops.extend(_ops_alter_model(prev[model_name], mstate))
+
+    for model_name, mstate in prev.items():
+        if model_name in curr:
+            continue
+        ops.append(DropTable(table_name=mstate["table_name"]))
+
+    if not ops:
+        return None
+
+    ts = datetime.utcnow().strftime("%Y%m%d%H%M%S")
+    name = f"{ts}_{_slug(name_suffix)}"
+    return Migration(name=name, operations=ops, state=curr, dependencies=[])
+
+
+def _ops_create_model(mstate: dict[str, Any]) -> list[Operation]:
+    columns: list[tuple[str, Any]] = []
+    fks: list[tuple[str, str, str, str]] = []
+
+    for col, fdef in mstate["fields"].items():
+        cls_name = fdef["__class__"]
+        if cls_name in {"ForeignKey", "OneToOne"}:
+            to = fdef["to"]
+            to_table = _resolve_table_name(to)
+            fks.append(
+                (
+                    col,
+                    to_table,
+                    fdef.get("to_field", "id"),
+                    fdef.get("on_delete", "RESTRICT"),
+                )
+            )
+            columns.append(
+                (
+                    col,
+                    {
+                        "__class__": "Int",
+                        "nullable": fdef.get("nullable"),
+                        "unique": fdef.get("unique", False),
+                        "index": fdef.get("index", False),
+                    },
+                )
+            )
+        else:
+            columns.append((col, fdef))
+
+    ops: list[Operation] = [
+        CreateTable(
+            table_name=mstate["table_name"],
+            columns=columns,
+            pk_name=mstate["pk_name"],
+            fks=fks,
+            unique_together=[],
+        )
+    ]
+
+    for _rel_name, rel in mstate.get("m2m", {}).items():
+        ops.extend(_ops_create_m2m(mstate, rel))
+    return ops
+
+
+def _ops_alter_model(prev: dict[str, Any], curr: dict[str, Any]) -> list[Operation]:
+    ops: list[Operation] = []
+    prev_fields: dict[str, Any] = prev.get("fields", {})
+    curr_fields: dict[str, Any] = curr.get("fields", {})
+
+    table = curr["table_name"]
+    for col, fdef in curr_fields.items():
+        if col in prev_fields:
+            continue
+        ops.append(AddColumn(table_name=table, column_name=col, column_def=fdef))
+
+    for col in prev_fields:
+        if col in curr_fields:
+            continue
+        ops.append(DropColumn(table_name=table, column_name=col))
+
+    return ops
+
+
+def _ops_create_m2m(mstate: dict[str, Any], rel: dict[str, Any]) -> list[Operation]:
+    to = rel["to"]
+    to_table = _resolve_table_name(to)
+    from_pk = mstate["pk_name"]
+    to_pk = "id"
+    through = rel.get("through") or f"{mstate['table_name']}_{to_table}".lower()
+    from_col = rel.get("from_field") or f"{mstate['table_name']}_{from_pk}"
+    to_col = rel.get("to_field") or f"{to_table.lower()}_{to_pk}"
+
+    columns = [
+        (from_col, {"__class__": "Int", "nullable": False}),
+        (to_col, {"__class__": "Int", "nullable": False}),
+    ]
+    fks = [
+        (from_col, mstate["table_name"], from_pk, "CASCADE"),
+        (to_col, to_table, to_pk, "CASCADE"),
+    ]
+    return [
+        CreateTable(
+            table_name=through,
+            columns=columns,
+            pk_name=from_col,
+            fks=fks,
+            unique_together=[(from_col, to_col)],
+        )
+    ]
+
+
+def _resolve_table_name(ref: Any) -> str:
+    if isinstance(ref, str):
+        try:
+            m = Model._resolve_model(ref)
+            return m.table_name()
+        except Exception:
+            return ref.lower()
+    if hasattr(ref, "table_name") and callable(ref.table_name):
+        return ref.table_name()
+    return str(ref).lower()

ns_orm/migrations/executor.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from ns_orm.database import AsyncDatabase
+from ns_orm.dialects import Dialect
+from ns_orm.migrations.loader import MigrationLoader
+from ns_orm.migrations.migration import Migration
+
+_MIGRATIONS_TABLE = "ns_orm_migrations"
+
+
+@dataclass
+class MigrationExecutor:
+    db: Any
+    dialect: Dialect
+    loader: MigrationLoader
+    is_async: bool = False
+
+    def plan(self) -> list[Migration]:
+        migrations = self.loader.load_all()
+        if not self.is_async:
+            applied = set(self._applied_sync())
+        else:
+            import asyncio
+
+            applied = set(asyncio.run(self._applied_async()))
+        return [m for m in migrations if m.name not in applied]
+
+    def migrate(self) -> None:
+        if isinstance(self.db, AsyncDatabase):
+            raise RuntimeError("Use amigrate() for AsyncDatabase")
+        self._ensure_table_sync()
+        applied = set(self._applied_sync())
+        for mig in self.loader.load_all():
+            if mig.name in applied:
+                continue
+            self._apply_migration_sync(mig)
+            self._record_sync(mig.name)
+
+    async def amigrate(self) -> None:
+        if not isinstance(self.db, AsyncDatabase):
+            raise RuntimeError("Use migrate() for sync Database")
+        await self._ensure_table_async()
+        applied = set(await self._applied_async())
+        for mig in self.loader.load_all():
+            if mig.name in applied:
+                continue
+            await self._apply_migration_async(mig)
+            await self._record_async(mig.name)
+
+    def _ensure_table_sync(self) -> None:
+        table = self.dialect.quote_ident(_MIGRATIONS_TABLE)
+        col_name = self.dialect.quote_ident("name")
+        col_applied_at = self.dialect.quote_ident("applied_at")
+        ddl = (
+            "CREATE TABLE IF NOT EXISTS {table} ("
+            "{col_name} VARCHAR(255) PRIMARY KEY, "
+            "{col_applied_at} VARCHAR(32) NOT NULL"
+            ")"
+        )
+        ddl = ddl.format(
+            table=table,
+            col_name=col_name,
+            col_applied_at=col_applied_at,
+        )
+        self.db.execute(ddl)
+
+    async def _ensure_table_async(self) -> None:
+        table = self.dialect.quote_ident(_MIGRATIONS_TABLE)
+        col_name = self.dialect.quote_ident("name")
+        col_applied_at = self.dialect.quote_ident("applied_at")
+        ddl = (
+            "CREATE TABLE IF NOT EXISTS {table} ("
+            "{col_name} VARCHAR(255) PRIMARY KEY, "
+            "{col_applied_at} VARCHAR(32) NOT NULL"
+            ")"
+        )
+        ddl = ddl.format(
+            table=table,
+            col_name=col_name,
+            col_applied_at=col_applied_at,
+        )
+        await self.db.execute(ddl)
+
+    def _applied_sync(self) -> list[str]:
+        table = self.dialect.quote_ident(_MIGRATIONS_TABLE)
+        col_name = self.dialect.quote_ident("name")
+        sql = "SELECT {col_name} AS name FROM {table}".format(
+            col_name=col_name, table=table
+        )
+        try:
+            rows = self.db.fetch_all(sql)
+        except Exception:
+            return []
+        return [r["name"] for r in rows]
+
+    async def _applied_async(self) -> list[str]:
+        table = self.dialect.quote_ident(_MIGRATIONS_TABLE)
+        col_name = self.dialect.quote_ident("name")
+        sql = "SELECT {col_name} AS name FROM {table}".format(
+            col_name=col_name, table=table
+        )
+        try:
+            rows = await self.db.fetch_all(sql)
+        except Exception:
+            return []
+        return [r["name"] for r in rows]
+
+    def _apply_migration_sync(self, mig: Migration) -> None:
+        with self.db.transaction():
+            for op in mig.operations:
+                for sql in op.sql(self.dialect):
+                    self.db.execute(sql)
+
+    async def _apply_migration_async(self, mig: Migration) -> None:
+        async with self.db.transaction():
+            for op in mig.operations:
+                for sql in op.sql(self.dialect):
+                    await self.db.execute(sql)
+
+    def _record_sync(self, name: str) -> None:
+        table = self.dialect.quote_ident(_MIGRATIONS_TABLE)
+        col_name = self.dialect.quote_ident("name")
+        col_applied_at = self.dialect.quote_ident("applied_at")
+        sql = "INSERT INTO {table} ({col_name}, {col_applied_at}) VALUES (:p1, :p2)"
+        sql = sql.format(
+            table=table,
+            col_name=col_name,
+            col_applied_at=col_applied_at,
+        )
+        self.db.execute(
+            sql, {"p1": name, "p2": datetime.utcnow().strftime("%Y%m%d%H%M%S")}
+        )
+
+    async def _record_async(self, name: str) -> None:
+        table = self.dialect.quote_ident(_MIGRATIONS_TABLE)
+        col_name = self.dialect.quote_ident("name")
+        col_applied_at = self.dialect.quote_ident("applied_at")
+        sql = "INSERT INTO {table} ({col_name}, {col_applied_at}) VALUES (:p1, :p2)"
+        sql = sql.format(
+            table=table,
+            col_name=col_name,
+            col_applied_at=col_applied_at,
+        )
+        await self.db.execute(
+            sql, {"p1": name, "p2": datetime.utcnow().strftime("%Y%m%d%H%M%S")}
+        )