dotorm 2.0.8__py3-none-any.whl

dotorm/orm/mixins/relations.py

@@ -0,0 +1,513 @@
+"""Relations ORM operations mixin."""
+
+from typing import TYPE_CHECKING, Any, Literal, Self, TypeVar
+
+from ...components.filter_parser import FilterExpression
+from ...decorators import hybridmethod
+from ...access import Operation
+from ...builder.request_builder import (
+    RequestBuilderForm,
+)
+from ...fields import (
+    AttachmentMany2one,
+    AttachmentOne2many,
+    Many2many,
+    Many2one,
+    One2many,
+    One2one,
+)
+from ..utils import execute_maybe_parallel
+
+if TYPE_CHECKING:
+    from ..protocol import DotModelProtocol
+    from ...model import DotModel
+
+    _Base = DotModelProtocol
+else:
+    _Base = object
+
+# TypeVar for generic payload - accepts any DotModel subclass
+_M = TypeVar("_M", bound="DotModel")
+
+
+class OrmRelationsMixin(_Base):
+    """
+    Mixin providing ORM operations for relations.
+
+    Provides:
+    - search - search records with relation loading
+    - search_count - count records matching filter
+    - exists - have one record or not
+    - get_with_relations - get single record with relations
+    - update_with_relations - update record with relations
+
+    Expects DotModel to provide:
+    - _get_db_session()
+    - _builder
+    - _dialect
+    - __table__
+    - get_fields(), get_store_fields(), get_relation_fields()
+    - get_relation_fields_m2m_o2m(), get_relation_fields_attachment()
+    - prepare_list_ids()
+    - get_many2many(), link_many2many(), unlink_many2many()
+    - _records_list_get_relation()
+    - update()
+    """
+
+    @hybridmethod
+    async def search(
+        self,
+        fields: list[str] = ["id"],
+        start: int | None = None,
+        end: int | None = None,
+        limit: int = 1000,
+        order: Literal["DESC", "ASC", "desc", "asc"] = "DESC",
+        sort: str = "id",
+        filter: FilterExpression | None = None,
+        raw: bool = False,
+        session=None,
+    ) -> list[Self]:
+        cls = self.__class__
+
+        # Access check + apply domain filter
+        filter = await cls._check_access(Operation.READ, filter=filter)
+
+        session = cls._get_db_session(session)
+
+        # Use dialect from class
+        dialect = cls._dialect
+
+        stmt, values = cls._builder.build_search(
+            fields, start, end, limit, order, sort, filter
+        )
+        prepare = cls.prepare_list_ids if not raw else None
+        records: list[Self] = await session.execute(
+            stmt, values, prepare=prepare
+        )
+
+        # если есть хоть одна запись и вообще нужно читать поля связей
+        fields_relation = [
+            (name, field)
+            for name, field in cls.get_relation_fields()
+            if name in fields
+        ]
+        if records and fields_relation:
+            await cls._records_list_get_relation(
+                session, fields_relation, records
+            )
+
+        return records
+
+    @hybridmethod
+    async def search_count(
+        self,
+        filter: FilterExpression | None = None,
+        session=None,
+    ) -> int:
+        """
+        Count records matching the filter.
+
+        Args:
+            filter: Filter expression
+            session: Database session
+
+        Returns:
+            Number of matching records
+        """
+        cls = self.__class__
+        session = cls._get_db_session(session)
+
+        stmt, values = cls._builder.build_search_count(filter)
+        result = await session.execute(stmt, values)
+
+        if result and len(result) > 0:
+            return result[0].get("count", 0)
+        return 0
+
+    @hybridmethod
+    async def exists(
+        self,
+        filter: FilterExpression | None = None,
+        session=None,
+    ) -> bool:
+        """
+        Check if any record matches the filter.
+
+        More efficient than search_count for existence checks.
+
+        Args:
+            filter: Filter expression
+            session: Database session
+
+        Returns:
+            True if at least one record exists
+        """
+        cls = self.__class__
+        session = cls._get_db_session(session)
+
+        stmt, values = cls._builder.build_exists(filter)
+        result = await session.execute(stmt, values)
+
+        return bool(result)
+
+    @classmethod
+    async def get_with_relations(
+        cls,
+        id,
+        fields=None,
+        fields_info={},
+        session=None,
+    ) -> Self:
+        """Get record with relations loaded."""
+        if not fields:
+            fields = []
+        session = cls._get_db_session(session)
+
+        dialect = cls._dialect
+
+        # защита, оставить только те поля, которые действительно хранятся в базе
+        fields_store = [
+            name for name in cls.get_store_fields() if name in fields
+        ]
+        # если вдруг они не заданы, или таких нет, взять все
+        if not fields_store:
+            fields_store = [name for name in cls.get_store_fields()]
+        if "id" not in fields_store:
+            fields_store.append("id")
+
+        stmt, values = cls._builder.build_get(id, fields_store)
+        record_raw: list[Any] = await session.execute(stmt, values)
+        if not record_raw:
+            raise ValueError("Record not found")
+        record = cls(**record_raw[0])
+
+        # защита, оставить только те поля, которые являются отношениями (m2m, o2m, m2o)
+        # добавлена информаци о вложенных полях
+        fields_relation = [
+            (name, field, fields_info.get(name))
+            for name, field in cls.get_relation_fields()
+            if name in fields
+        ]
+
+        # если есть хоть одна запись и вообще нужно читать поля связей
+        if record and fields_relation:
+            request_list = []
+            execute_list = []
+
+            # добавить запрос на o2m
+            for name, field, fields_nested in fields_relation:
+                relation_table = field.relation_table
+                relation_table_field = field.relation_table_field
+
+                if not fields_nested and relation_table:
+                    fields_select = ["id"]
+                    if relation_table.get_fields().get("name"):
+                        fields_select.append("name")
+                    if isinstance(field, AttachmentMany2one):
+                        fields_select = (
+                            relation_table.get_store_fields_omit_m2o()
+                        )
+                else:
+                    fields_select = fields_nested
+
+                if (
+                    isinstance(field, (Many2one, AttachmentMany2one))
+                    and relation_table
+                ):
+                    m2o_id = getattr(record, name)
+                    stmt, val = relation_table._builder.build_get(
+                        m2o_id, fields=fields_select
+                    )
+                    req = RequestBuilderForm(
+                        stmt=stmt,
+                        value=val,
+                        field_name=name,
+                        field=field,
+                        fields=fields_select,
+                    )
+                    request_list.append(req)
+                    execute_list.append(
+                        session.execute(
+                            req.stmt,
+                            req.value,
+                            prepare=req.function_prepare,
+                            cursor=req.function_cursor,
+                        )
+                    )
+                # если m2m или o2m необходимо посчитать длину, для пагинации
+                if isinstance(field, Many2many):
+                    params = {
+                        "id": record.id,
+                        "comodel": relation_table,
+                        "relation": field.many2many_table,
+                        "column1": field.column1,
+                        "column2": field.column2,
+                        "fields": fields_select,
+                        "order": "desc",
+                        "start": 0,
+                        "end": 40,
+                        "sort": "id",
+                        "limit": 40,
+                    }
+                    # records
+                    execute_list.append(cls.get_many2many(**params))
+                    params["fields"] = ["id"]
+                    params["start"] = None
+                    params["end"] = None
+                    params["limit"] = None
+                    # len
+                    execute_list.append(cls.get_many2many(**params))
+                    req = RequestBuilderForm(
+                        stmt=None,
+                        value=None,
+                        field_name=name,
+                        field=field,
+                        fields=fields_select,
+                    )
+                    request_list.append(req)
+
+                if isinstance(field, One2many) and relation_table:
+                    params = {
+                        "start": 0,
+                        "end": 40,
+                        "limit": 40,
+                        "fields": fields_select,
+                        "filter": [(relation_table_field, "=", record.id)],
+                    }
+                    execute_list.append(relation_table.search(**params))
+                    params["fields"] = ["id"]
+                    params["start"] = None
+                    params["end"] = None
+                    params["limit"] = 1000
+                    execute_list.append(relation_table.search(**params))
+                    req = RequestBuilderForm(
+                        stmt=None,
+                        value=None,
+                        field_name=name,
+                        field=field,
+                        fields=fields_select,
+                    )
+                    request_list.append(req)
+
+                if isinstance(field, AttachmentOne2many) and relation_table:
+                    params = {
+                        "start": 0,
+                        "end": 40,
+                        "limit": 40,
+                        "fields": relation_table.get_store_fields_omit_m2o(),
+                        "filter": [
+                            ("res_id", "=", record.id),
+                            ("res_model", "=", record.__table__),
+                        ],
+                    }
+                    execute_list.append(relation_table.search(**params))
+                    params["fields"] = ["id"]
+                    params["start"] = None
+                    params["end"] = None
+                    params["limit"] = 1000
+                    execute_list.append(relation_table.search(**params))
+                    req = RequestBuilderForm(
+                        stmt=None,
+                        value=None,
+                        field_name=name,
+                        field=field,
+                        fields=relation_table.get_store_fields_omit_m2o(),
+                    )
+                    request_list.append(req)
+
+                if isinstance(field, One2one) and relation_table:
+                    params = {
+                        "limit": 1,
+                        "fields": fields_select,
+                        "filter": [(relation_table_field, "=", record.id)],
+                    }
+                    execute_list.append(relation_table.search(**params))
+                    req = RequestBuilderForm(
+                        stmt=None,
+                        value=None,
+                        field_name=name,
+                        field=field,
+                        fields=fields_select,
+                    )
+                    request_list.append(req)
+
+            # выполняем последовательно в транзакции, параллельно вне транзакции
+            results = await execute_maybe_parallel(execute_list)
+
+            # добавляем атрибуты к исходному объекту,
+            # получая удобное обращение через дот-нотацию
+            i = 0
+            for request_builder in request_list:
+                result = results[i]
+
+                if isinstance(
+                    request_builder.field,
+                    (Many2one, AttachmentMany2one, One2one),
+                ):
+                    # m2o нужно распаковать так как он тоже в списке
+                    # если пустой список, то установить None
+                    result = result[0] if result else None
+
+                if isinstance(
+                    request_builder.field,
+                    (Many2many, One2many, AttachmentOne2many),
+                ):
+                    # если m2m или o2m необбзодимо взять два результатата
+                    # так как один из них это число всех строк таблицы
+                    # для пагинации
+                    fields_info = request_builder.field.relation_table.get_fields_info_list(
+                        request_builder.fields
+                    )
+                    result = {
+                        "data": result,
+                        "fields": fields_info,
+                        "total": len(results[i + 1]),
+                    }
+                    i += 1
+
+                setattr(record, request_builder.field_name, result)
+                i += 1
+
+        return record
+
+    async def update_with_relations(
+        self, payload: _M, fields=[], session=None
+    ):
+        """Update record with relations."""
+        session = self._get_db_session(session)
+
+        # Handle attachments
+        fields_attachments = [
+            (name, field)
+            for name, field in self.get_relation_fields_attachment()
+            if name in fields
+        ]
+
+        if fields_attachments:
+            for name, field in fields_attachments:
+                if isinstance(field, AttachmentMany2one):
+                    field_obj = getattr(payload, name)
+                    if field_obj and field.relation_table:
+                        # TODO: всегда создавать новую строку аттачмент с файлом
+                        # также надо продумать механизм обновления уже существующего файла
+                        # надо ли? или проще удалять
+                        field_obj["res_id"] = self.id
+                        # Оборачиваем dict в объект модели
+                        attachment_payload = field.relation_table(**field_obj)
+                        attachment_id = await field.relation_table.create(
+                            attachment_payload, session
+                        )
+                        setattr(payload, name, attachment_id)
+
+        # Update stored fields
+        fields_store = [
+            name for name in self.get_store_fields() if name in fields
+        ]
+        # Обновление сущности в базе без связей
+        if fields_store:
+            record_raw = await self.update(payload, fields, session)
+
+        # защита, оставить только те поля, которые являются отношениями (m2m, o2m)
+        # добавлена информаци о вложенных полях
+        fields_relation = [
+            (name, field)
+            for name, field in self.get_relation_fields_m2m_o2m()
+            if name in fields
+        ]
+
+        if fields_relation:
+            request_list = []
+            field_list = []
+
+            for name, field in fields_relation:
+                field_obj = getattr(payload, name)
+
+                if isinstance(field, One2one):
+                    params = {
+                        "limit": 1,
+                        "fields": ["id"],
+                        "filter": [(field.relation_table_field, "=", self.id)],
+                    }
+                    record = await field.relation_table.search(**params)
+                    if len(record):
+                        request_list.append(record[0].update(field_obj))
+
+                if isinstance(field, (One2many, AttachmentOne2many)):
+                    field_list.append(field)
+                    # заменить в связанных полях виртуальный ид на вновь созданный
+                    for obj in field_obj["created"]:
+                        for k, v in obj.items():
+                            f = getattr(field.relation_table, k)
+                            if (
+                                isinstance(f, (Many2one, AttachmentMany2one))
+                                and v == "VirtualId"
+                            ):
+                                obj[k] = self.id
+
+                    data_created = [
+                        field.relation_table(**obj)
+                        for obj in field_obj["created"]
+                    ]
+
+                    if isinstance(field, AttachmentOne2many):
+                        for obj in data_created:
+                            obj.res_id = self.id
+
+                    if field_obj["created"]:
+                        request_list.append(
+                            field.relation_table.create_bulk(data_created)
+                        )
+                    if field_obj["deleted"]:
+                        request_list.append(
+                            field.relation_table.delete_bulk(
+                                field_obj["deleted"]
+                            )
+                        )
+
+                if isinstance(field, Many2many):
+                    field_list.append(field)
+
+                    # Replace virtual ID
+                    for obj in field_obj["created"]:
+                        for k, v in obj.items():
+                            f = getattr(field.relation_table, k)
+                            if (
+                                isinstance(f, (Many2one, AttachmentMany2one))
+                                and v == "VirtualId"
+                            ):
+                                obj[k] = self.id
+
+                    data_created = [
+                        field.relation_table(**obj)
+                        for obj in field_obj["created"]
+                    ]
+
+                    if field_obj["created"]:
+                        created_ids = await field.relation_table.create_bulk(
+                            data_created
+                        )
+                        if "selected" not in field_obj:
+                            field_obj["selected"] = []
+                        field_obj["selected"] += [
+                            rec["id"] for rec in created_ids
+                        ]
+
+                    if field_obj.get("selected"):
+                        data_selected = [
+                            (self.id, id) for id in field_obj["selected"]
+                        ]
+                        request_list.append(
+                            self.link_many2many(field, data_selected)
+                        )
+
+                    if field_obj.get("unselected"):
+                        request_list.append(
+                            self.unlink_many2many(
+                                field, field_obj["unselected"]
+                            )
+                        )
+
+            # выполняем последовательно
+            results = await execute_maybe_parallel(request_list)
+
+        return record_raw

dotorm/orm/protocol.py

@@ -0,0 +1,147 @@
+"""Protocols defining what ORM mixins expect from the model class."""
+
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Protocol,
+    Self,
+    Type,
+    Union,
+    runtime_checkable,
+)
+
+if TYPE_CHECKING:
+    from ..builder.builder import Builder
+    from ..components.dialect import Dialect
+    from ..fields import Field
+    from ..access import Operation
+    import aiomysql
+    import asyncpg
+
+
+@runtime_checkable
+class DotModelProtocol(Protocol):
+    """
+    Base protocol that all ORM mixins expect.
+
+    Defines the full interface that DotModel provides.
+    All mixins inherit from this protocol for type checking.
+    """
+
+    __table__: ClassVar[str]
+    __auto_create__: ClassVar[bool] = True
+    _pool: ClassVar[Union["aiomysql.Pool", "asyncpg.Pool"]]
+    _no_transaction: ClassVar[Type]
+    _dialect: ClassVar["Dialect"]
+    _builder: ClassVar["Builder"]
+
+    id: int
+
+    # Session
+    @classmethod
+    def _get_db_session(cls, session=None) -> Any: ...
+
+    # Access control (from AccessMixin)
+    @classmethod
+    async def _check_access(
+        cls,
+        operation: "Operation",
+        record_ids: list[int] | None = None,
+        filter: list | None = None,
+    ) -> list | None: ...
+
+    # Field introspection
+    @classmethod
+    def get_fields(cls) -> dict[str, "Field"]: ...
+
+    @classmethod
+    def get_store_fields(cls) -> list[str]: ...
+
+    @classmethod
+    def get_store_fields_omit_m2o(cls) -> list[str]: ...
+
+    @classmethod
+    def get_relation_fields(cls) -> list[tuple[str, "Field"]]: ...
+
+    @classmethod
+    def get_relation_fields_m2m_o2m(cls) -> list[tuple[str, "Field"]]: ...
+
+    @classmethod
+    def get_relation_fields_attachment(cls) -> list[tuple[str, "Field"]]: ...
+
+    # Serialization
+    @classmethod
+    def prepare_list_ids(cls, rows: list[dict]) -> list[Self]: ...
+
+    @classmethod
+    def prepare_form_id(cls, r: list) -> Self | None: ...
+
+    def json(
+        self,
+        include: Any = ...,
+        exclude: Any = ...,
+        exclude_none: bool = ...,
+        exclude_unset: bool = ...,
+        only_store: Any = ...,
+        mode: Any = ...,
+    ) -> dict[str, Any]: ...
+
+    @classmethod
+    def get_none_update_fields_set(cls) -> set[str]: ...
+
+    def __init__(self, **kwargs: Any) -> None: ...
+
+    # From OrmPrimaryMixin
+    async def update(
+        self,
+        payload: Self | None = None,
+        fields: Any = None,
+        session: Any = None,
+    ) -> Any: ...
+
+    # From OrmMany2manyMixin
+    @classmethod
+    async def get_many2many(
+        cls,
+        id: int,
+        comodel: Any,
+        relation: str,
+        column1: str,
+        column2: str,
+        fields: list[str] | None = None,
+        order: str = "desc",
+        start: int | None = None,
+        end: int | None = None,
+        sort: str = "id",
+        limit: int | None = 10,
+        session: Any = None,
+    ) -> list[Any]: ...
+
+    @classmethod
+    async def link_many2many(
+        cls,
+        field: Any,
+        values: list,
+        session: Any = None,
+    ) -> Any: ...
+
+    @classmethod
+    async def unlink_many2many(
+        cls,
+        field: Any,
+        ids: list,
+        session: Any = None,
+    ) -> Any: ...
+
+    @classmethod
+    async def _records_list_get_relation(
+        cls,
+        session: Any,
+        fields_relation: list[tuple[str, "Field"]],
+        records: list[Any],
+    ) -> None: ...
+
+    # From DDLMixin
+    @staticmethod
+    def format_default_value(value: Any) -> str: ...

dotorm/orm/utils.py

@@ -0,0 +1,39 @@
+"""Utility functions for dotorm."""
+
+import asyncio
+from typing import Any, Coroutine, Sequence
+
+
+async def execute_maybe_parallel(
+    coroutines: Sequence[Coroutine[Any, Any, Any]],
+) -> list[Any]:
+    """
+    Execute coroutines in parallel or sequentially depending on transaction context.
+    
+    If inside a transaction (single connection), executes sequentially to avoid
+    asyncpg "another operation is in progress" error.
+    
+    If outside transaction (pool), executes in parallel for better performance.
+    
+    Args:
+        coroutines: List of coroutines to execute
+        
+    Returns:
+        List of results in the same order as input coroutines
+    """
+    from ..databases.postgres.transaction import get_current_session
+    
+    if not coroutines:
+        return []
+    
+    # Check if we're inside a transaction
+    if get_current_session() is not None:
+        # Inside transaction - execute sequentially
+        results = []
+        for coro in coroutines:
+            result = await coro
+            results.append(result)
+        return results
+    else:
+        # Outside transaction - execute in parallel
+        return list(await asyncio.gather(*coroutines))