ns-orm 0.0.2__tar.gz → 0.0.4__tar.gz

{ns_orm-0.0.2/src/ns_orm.egg-info → ns_orm-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ns-orm
-Version: 0.0.2
+Version: 0.0.4
 Summary: A ORM built on Pydantic models.
 Author: ns-orm contributors
 License:                                  Apache License

{ns_orm-0.0.2 → ns_orm-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ns-orm"
-version = "0.0.2"
+version = "0.0.4"
 description = "A ORM built on Pydantic models."
 readme = "README.md"
 requires-python = ">=3.7"

{ns_orm-0.0.2 → ns_orm-0.0.4}/src/ns_orm/manager.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic, TypeVar, Union
 
 from ns_orm.database import AsyncDatabase, Database, get_connection
 from ns_orm.query import AsyncQuerySet, QuerySet
@@ -47,18 +47,24 @@ class Manager(Generic[TModel]):
     async def aall(self) -> list[TModel]:
         return await self.aqs().all()
 
-    def filter(self, **lookups: Any) -> Any:
+    def filter(self, **lookups: Any) -> Union[QuerySet[TModel], AsyncQuerySet[TModel]]:
         db = self._get_db()
         if isinstance(db, AsyncDatabase):
             return self.aqs().filter(**lookups)
         return self.qs().filter(**lookups)
 
-    def exclude(self, **lookups: Any) -> Any:
+    def exclude(self, **lookups: Any) -> Union[QuerySet[TModel], AsyncQuerySet[TModel]]:
         db = self._get_db()
         if isinstance(db, AsyncDatabase):
             return self.aqs().exclude(**lookups)
         return self.qs().exclude(**lookups)
 
+    def order_by(self, *fields: str) -> Union[QuerySet[TModel], AsyncQuerySet[TModel]]:
+        db = self._get_db()
+        if isinstance(db, AsyncDatabase):
+            return self.aqs().order_by(*fields)
+        return self.qs().order_by(*fields)
+
     def get(self, **lookups: Any) -> TModel:
         return self.qs().get(**lookups)
 

{ns_orm-0.0.2 → ns_orm-0.0.4}/src/ns_orm/model.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import Any, ClassVar, Dict, Type, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, Type, TypeVar
 
 from pydantic import BaseModel
 
@@ -18,6 +18,9 @@ from ns_orm.utils import (
 
 TModel = TypeVar("TModel", bound="Model")
 
+if TYPE_CHECKING:
+    from ns_orm.manager import Manager
+
 
 def _default_table_name(cls_name: str) -> str:
     s1 = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", cls_name)
@@ -31,7 +34,7 @@ class Model(BaseModel):
 
     _meta: ClassVar[ModelMetaInfo]
     _registry: ClassVar[Dict[str, Type["Model"]]] = {}
-    objects: ClassVar[Any]
+    objects: ClassVar["Manager[Any]"]
 
     @classmethod
     def table_name(cls) -> str:

{ns_orm-0.0.2 → ns_orm-0.0.4}/src/ns_orm/query.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, replace
-from typing import Any, Generic, Optional, TypeVar
+from typing import Any, Dict, Generic, Optional, TypeVar
 
 from ns_orm.database import AsyncDatabase, Database
 from ns_orm.dialects import Dialect
@@ -23,6 +23,155 @@ def _qualified_table(model: type[Any], dialect: Dialect) -> str:
     return table
 
 
+_LOOKUP_OPS = {
+    "exact",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "in",
+    "contains",
+    "icontains",
+    "startswith",
+    "istartswith",
+    "endswith",
+    "iendswith",
+    "isnull",
+}
+
+
+def _parse_lookup(lookup: str) -> tuple[list[str], str, str]:
+    parts = lookup.split("__")
+    if not parts:
+        raise QueryError(f"Invalid lookup: {lookup}")
+    op = "exact"
+    if parts[-1] in _LOOKUP_OPS:
+        op = parts[-1]
+        path = parts[:-1]
+    else:
+        path = parts
+    if not path:
+        raise QueryError(f"Invalid lookup: {lookup}")
+    field = path[-1]
+    rel_path = path[:-1]
+    return rel_path, field, op
+
+
+class _JoinBuilder:
+    def __init__(self, *, model: type[Any], dialect: Dialect, base_alias: str) -> None:
+        self.model = model
+        self.dialect = dialect
+        self.base_alias = base_alias
+        self._joins: list[str] = []
+        self._aliases: Dict[tuple[str, str], str] = {}
+        self._targets: Dict[tuple[str, str], type[Any]] = {}
+        self._alias_counter: int = 0
+        self.needs_distinct: bool = False
+
+    @property
+    def joins(self) -> list[str]:
+        return list(self._joins)
+
+    def _new_alias(self) -> str:
+        self._alias_counter += 1
+        return f"t{self._alias_counter}"
+
+    def _resolve_to_model(self, from_model: type[Any], to_ref: Any) -> type[Any]:
+        if isinstance(to_ref, str):
+            return from_model._resolve_model(to_ref)
+        return to_ref
+
+    def _ensure_join(
+        self,
+        *,
+        from_model: type[Any],
+        from_alias: str,
+        rel_name: str,
+    ) -> tuple[type[Any], str]:
+        key = (from_alias, rel_name)
+        if key in self._aliases:
+            return self._targets[key], self._aliases[key]
+
+        if rel_name not in from_model._meta.relations:
+            to_model, fk_col = self._resolve_reverse_relation(
+                from_model=from_model, rel_name=rel_name
+            )
+            alias = self._new_alias()
+            self._aliases[key] = alias
+            self._targets[key] = to_model
+            self.needs_distinct = True
+
+            left = f"{alias}.{self.dialect.quote_ident(fk_col)}"
+            right = f"{from_alias}.{self.dialect.quote_ident(from_model.pk_name())}"
+            join_sql = (
+                f"JOIN {_qualified_table(to_model, self.dialect)} {alias} "
+                f"ON {left} = {right}"
+            )
+            self._joins.append(join_sql)
+            return to_model, alias
+
+        fk_col, fk = from_model._meta.relations[rel_name]
+        to_model = self._resolve_to_model(from_model, fk.to)
+        alias = self._new_alias()
+        self._aliases[key] = alias
+        self._targets[key] = to_model
+
+        left = f"{from_alias}.{self.dialect.quote_ident(fk_col)}"
+        right = f"{alias}.{self.dialect.quote_ident(to_model.pk_name())}"
+        join_sql = (
+            f"JOIN {_qualified_table(to_model, self.dialect)} {alias} "
+            f"ON {left} = {right}"
+        )
+        self._joins.append(join_sql)
+        return to_model, alias
+
+    def _resolve_reverse_relation(
+        self, *, from_model: type[Any], rel_name: str
+    ) -> tuple[type[Any], str]:
+        registry = getattr(from_model, "_registry", {})
+        seen: set[int] = set()
+        candidates: list[tuple[type[Any], str]] = []
+
+        for m in registry.values():
+            if not isinstance(m, type):
+                continue
+            if id(m) in seen:
+                continue
+            seen.add(id(m))
+            meta = getattr(m, "_meta", None)
+            if meta is None:
+                continue
+            for _child_rel_name, (fk_col, fk) in meta.relations.items():
+                to_model = self._resolve_to_model(m, fk.to)
+                if to_model is not from_model:
+                    continue
+                names = {
+                    m.__name__.lower(),
+                    m.table_name(),
+                    f"{m.__name__.lower()}_set",
+                    f"{m.table_name()}_set",
+                    f"{m.__name__.lower()}s",
+                    f"{m.table_name()}s",
+                }
+                if rel_name in names:
+                    candidates.append((m, fk_col))
+
+        if not candidates:
+            raise QueryError(f"Unknown relation: {rel_name}")
+        if len(candidates) > 1:
+            raise QueryError(f"Ambiguous reverse relation: {rel_name}")
+        return candidates[0]
+
+    def resolve(self, rel_path: list[str]) -> tuple[type[Any], str]:
+        model: type[Any] = self.model
+        alias = self.base_alias
+        for rel in rel_path:
+            model, alias = self._ensure_join(
+                from_model=model, from_alias=alias, rel_name=rel
+            )
+        return model, alias
+
+
 def _where_from_q(
     model: type[Any],
     dialect: Dialect,
@@ -31,6 +180,8 @@ def _where_from_q(
     table_alias: Optional[str] = None,
     param_prefix: str = "p",
     start_index: int = 1,
+    join_builder: Optional[_JoinBuilder] = None,
+    allow_joins: bool = True,
 ) -> tuple[str, dict[str, Any]]:
     def _lookup_compiler(
         *,
@@ -40,13 +191,19 @@ def _where_from_q(
         param_prefix: str,
         start_index: int,
     ) -> tuple[Condition, int]:
-        parts = lookup.split("__")
-        field = parts[0]
-        op = parts[1] if len(parts) > 1 else "exact"
-        if field not in model._meta.fields:
+        rel_path, field, op = _parse_lookup(lookup)
+
+        target_model = model
+        target_alias = table_alias
+        if rel_path:
+            if not allow_joins or join_builder is None or not table_alias:
+                raise QueryError(f"Join lookup is not supported here: {lookup}")
+            target_model, target_alias = join_builder.resolve(rel_path)
+
+        if field not in target_model._meta.fields:
             raise QueryError(f"Unknown field: {field}")
 
-        col_prefix = f"{table_alias}." if table_alias else ""
+        col_prefix = f"{target_alias}." if target_alias else ""
         col = f"{col_prefix}{dialect.quote_ident(field)}"
 
         if op == "exact":
@@ -180,10 +337,9 @@ class QuerySet(Generic[TModel]):
             cols.append(f"{alias}.{col} AS {col}")
         return cols
 
-    def _order_by_sql(self) -> str:
+    def _order_by_sql(self, *, join_builder: _JoinBuilder) -> str:
         if not self.state.order_by:
             return ""
-        alias = _table_alias()
         parts: list[str] = []
         for f in self.state.order_by:
             direction = "ASC"
@@ -191,19 +347,44 @@ class QuerySet(Generic[TModel]):
             if f.startswith("-"):
                 direction = "DESC"
                 name = f[1:]
-            if name not in self.model._meta.fields:
+            path = name.split("__")
+            rel_path = path[:-1]
+            field = path[-1]
+
+            target_model = self.model
+            target_alias = join_builder.base_alias
+            if rel_path:
+                target_model, target_alias = join_builder.resolve(rel_path)
+
+            if field not in target_model._meta.fields:
                 raise QueryError(f"Unknown order_by field: {name}")
-            parts.append(f"{alias}.{self.db.dialect.quote_ident(name)} {direction}")
+            parts.append(
+                f"{target_alias}.{self.db.dialect.quote_ident(field)} {direction}"
+            )
         return " ORDER BY " + ", ".join(parts)
 
     def _select_sql(self) -> tuple[str, dict[str, Any]]:
-        where_sql, params = _where_from_q(self.model, self.db.dialect, self.state.where)
+        join_builder = _JoinBuilder(
+            model=self.model, dialect=self.db.dialect, base_alias=_table_alias()
+        )
+        where_sql, params = _where_from_q(
+            self.model,
+            self.db.dialect,
+            self.state.where,
+            table_alias=_table_alias(),
+            join_builder=join_builder,
+        )
         cols = ", ".join(self._select_columns())
+        order_sql = self._order_by_sql(join_builder=join_builder)
+        select_kw = "SELECT DISTINCT" if join_builder.needs_distinct else "SELECT"
         sql = (
-            f"SELECT {cols} FROM {_qualified_table(self.model, self.db.dialect)} "
-            f"{_table_alias()} WHERE {where_sql}"
+            f"{select_kw} {cols} FROM {_qualified_table(self.model, self.db.dialect)} "
+            f"{_table_alias()}"
         )
-        sql += self._order_by_sql()
+        if join_builder.joins:
+            sql += " " + " ".join(join_builder.joins)
+        sql += f" WHERE {where_sql}"
+        sql += order_sql
         sql = self.db.dialect.apply_limit_offset(
             sql, self.state.limit, self.state.offset
         )
@@ -278,12 +459,17 @@ class QuerySet(Generic[TModel]):
         set_cols = [k for k in data.keys() if k in self.model._meta.fields]
         if not set_cols:
             return 0
+        table = _qualified_table(self.model, self.db.dialect)
+        join_builder = _JoinBuilder(
+            model=self.model, dialect=self.db.dialect, base_alias=_table_alias()
+        )
         where_sql, where_params = _where_from_q(
             self.model,
             self.db.dialect,
             self.state.where,
-            table_alias="",
+            table_alias=_table_alias(),
             param_prefix="w",
+            join_builder=join_builder,
         )
         sets = []
         params: dict[str, Any] = {}
@@ -294,18 +480,38 @@ class QuerySet(Generic[TModel]):
             sets.append(f"{self.db.dialect.quote_ident(c)} = :{key}")
             params[key] = data[c]
         params.update(where_params)
-        sql = (
-            f"UPDATE {_qualified_table(self.model, self.db.dialect)} "
-            f"SET {', '.join(sets)} WHERE {where_sql}"
-        )
+        pk = self.model.pk_name()
+        outer_pk = f"{table}.{self.db.dialect.quote_ident(pk)}"
+        corr = f"{_table_alias()}.{self.db.dialect.quote_ident(pk)} = {outer_pk}"
+        sub = f"SELECT 1 FROM {table} {_table_alias()}"
+        if join_builder.joins:
+            sub += " " + " ".join(join_builder.joins)
+        sub += f" WHERE {corr} AND {where_sql}"
+        exists_sql = f"EXISTS ({sub})"
+        sql = f"UPDATE {table} SET {', '.join(sets)} WHERE {exists_sql}"
         return self.db.execute(sql, params)
 
     def delete(self) -> int:
+        table = _qualified_table(self.model, self.db.dialect)
+        join_builder = _JoinBuilder(
+            model=self.model, dialect=self.db.dialect, base_alias=_table_alias()
+        )
         where_sql, params = _where_from_q(
-            self.model, self.db.dialect, self.state.where, table_alias=""
+            self.model,
+            self.db.dialect,
+            self.state.where,
+            table_alias=_table_alias(),
+            join_builder=join_builder,
         )
-        table = _qualified_table(self.model, self.db.dialect)
-        sql = f"DELETE FROM {table} WHERE {where_sql}"
+        pk = self.model.pk_name()
+        outer_pk = f"{table}.{self.db.dialect.quote_ident(pk)}"
+        corr = f"{_table_alias()}.{self.db.dialect.quote_ident(pk)} = {outer_pk}"
+        sub = f"SELECT 1 FROM {table} {_table_alias()}"
+        if join_builder.joins:
+            sub += " " + " ".join(join_builder.joins)
+        sub += f" WHERE {corr} AND {where_sql}"
+        exists_sql = f"EXISTS ({sub})"
+        sql = f"DELETE FROM {table} WHERE {exists_sql}"
         return self.db.execute(sql, params)
 
     def _prefetch(self, instances: list[Any]) -> None:
@@ -458,10 +664,9 @@ class AsyncQuerySet(Generic[TModel]):
             cols.append(f"{alias}.{col} AS {col}")
         return cols
 
-    def _order_by_sql(self) -> str:
+    def _order_by_sql(self, *, join_builder: _JoinBuilder) -> str:
         if not self.state.order_by:
             return ""
-        alias = _table_alias()
         parts: list[str] = []
         for f in self.state.order_by:
             direction = "ASC"
@@ -469,19 +674,44 @@ class AsyncQuerySet(Generic[TModel]):
             if f.startswith("-"):
                 direction = "DESC"
                 name = f[1:]
-            if name not in self.model._meta.fields:
+            path = name.split("__")
+            rel_path = path[:-1]
+            field = path[-1]
+
+            target_model = self.model
+            target_alias = join_builder.base_alias
+            if rel_path:
+                target_model, target_alias = join_builder.resolve(rel_path)
+
+            if field not in target_model._meta.fields:
                 raise QueryError(f"Unknown order_by field: {name}")
-            parts.append(f"{alias}.{self.db.dialect.quote_ident(name)} {direction}")
+            parts.append(
+                f"{target_alias}.{self.db.dialect.quote_ident(field)} {direction}"
+            )
         return " ORDER BY " + ", ".join(parts)
 
     def _select_sql(self) -> tuple[str, dict[str, Any]]:
-        where_sql, params = _where_from_q(self.model, self.db.dialect, self.state.where)
+        join_builder = _JoinBuilder(
+            model=self.model, dialect=self.db.dialect, base_alias=_table_alias()
+        )
+        where_sql, params = _where_from_q(
+            self.model,
+            self.db.dialect,
+            self.state.where,
+            table_alias=_table_alias(),
+            join_builder=join_builder,
+        )
         cols = ", ".join(self._select_columns())
+        order_sql = self._order_by_sql(join_builder=join_builder)
+        select_kw = "SELECT DISTINCT" if join_builder.needs_distinct else "SELECT"
         sql = (
-            f"SELECT {cols} FROM {_qualified_table(self.model, self.db.dialect)} "
-            f"{_table_alias()} WHERE {where_sql}"
+            f"{select_kw} {cols} FROM {_qualified_table(self.model, self.db.dialect)} "
+            f"{_table_alias()}"
         )
-        sql += self._order_by_sql()
+        if join_builder.joins:
+            sql += " " + " ".join(join_builder.joins)
+        sql += f" WHERE {where_sql}"
+        sql += order_sql
         sql = self.db.dialect.apply_limit_offset(
             sql, self.state.limit, self.state.offset
         )
@@ -556,12 +786,17 @@ class AsyncQuerySet(Generic[TModel]):
         set_cols = [k for k in data.keys() if k in self.model._meta.fields]
         if not set_cols:
             return 0
+        table = _qualified_table(self.model, self.db.dialect)
+        join_builder = _JoinBuilder(
+            model=self.model, dialect=self.db.dialect, base_alias=_table_alias()
+        )
         where_sql, where_params = _where_from_q(
             self.model,
             self.db.dialect,
             self.state.where,
-            table_alias="",
+            table_alias=_table_alias(),
             param_prefix="w",
+            join_builder=join_builder,
         )
         sets = []
         params: dict[str, Any] = {}
@@ -572,18 +807,38 @@ class AsyncQuerySet(Generic[TModel]):
             sets.append(f"{self.db.dialect.quote_ident(c)} = :{key}")
             params[key] = data[c]
         params.update(where_params)
-        sql = (
-            f"UPDATE {_qualified_table(self.model, self.db.dialect)} "
-            f"SET {', '.join(sets)} WHERE {where_sql}"
-        )
+        pk = self.model.pk_name()
+        outer_pk = f"{table}.{self.db.dialect.quote_ident(pk)}"
+        corr = f"{_table_alias()}.{self.db.dialect.quote_ident(pk)} = {outer_pk}"
+        sub = f"SELECT 1 FROM {table} {_table_alias()}"
+        if join_builder.joins:
+            sub += " " + " ".join(join_builder.joins)
+        sub += f" WHERE {corr} AND {where_sql}"
+        exists_sql = f"EXISTS ({sub})"
+        sql = f"UPDATE {table} SET {', '.join(sets)} WHERE {exists_sql}"
         return await self.db.execute(sql, params)
 
     async def delete(self) -> int:
+        table = _qualified_table(self.model, self.db.dialect)
+        join_builder = _JoinBuilder(
+            model=self.model, dialect=self.db.dialect, base_alias=_table_alias()
+        )
         where_sql, params = _where_from_q(
-            self.model, self.db.dialect, self.state.where, table_alias=""
+            self.model,
+            self.db.dialect,
+            self.state.where,
+            table_alias=_table_alias(),
+            join_builder=join_builder,
         )
-        table = _qualified_table(self.model, self.db.dialect)
-        sql = f"DELETE FROM {table} WHERE {where_sql}"
+        pk = self.model.pk_name()
+        outer_pk = f"{table}.{self.db.dialect.quote_ident(pk)}"
+        corr = f"{_table_alias()}.{self.db.dialect.quote_ident(pk)} = {outer_pk}"
+        sub = f"SELECT 1 FROM {table} {_table_alias()}"
+        if join_builder.joins:
+            sub += " " + " ".join(join_builder.joins)
+        sub += f" WHERE {corr} AND {where_sql}"
+        exists_sql = f"EXISTS ({sub})"
+        sql = f"DELETE FROM {table} WHERE {exists_sql}"
         return await self.db.execute(sql, params)
 
     async def _prefetch(self, instances: list[Any]) -> None:

{ns_orm-0.0.2 → ns_orm-0.0.4/src/ns_orm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ns-orm
-Version: 0.0.2
+Version: 0.0.4
 Summary: A ORM built on Pydantic models.
 Author: ns-orm contributors
 License:                                  Apache License