dotorm 2.0.8__py3-none-any.whl

dotorm/builder/mixins/m2m.py

@@ -0,0 +1,110 @@
+"""Many2many query builder."""
+
+from typing import TYPE_CHECKING, Literal
+
+if TYPE_CHECKING:
+    from ..protocol import BuilderProtocol
+    from ...orm.model import DotModel
+
+
+class Many2ManyMixin:
+    """Mixin for many-to-many relation queries."""
+
+    __slots__ = ()
+
+    def build_get_many2many(
+        self: "BuilderProtocol",
+        id: int,
+        relation_table: "DotModel",
+        many2many_table: str,
+        column1: str,
+        column2: str,
+        fields: list[str],
+        order: Literal["desc", "asc"] = "desc",
+        start: int | None = None,
+        end: int | None = None,
+        sort: str = "id",
+        limit: int | None = 10,
+    ) -> tuple[str, tuple]:
+        """Build SELECT for M2M relation."""
+        if not fields:
+            fields = relation_table.get_store_fields()
+
+        # явно указать для sql запроса что эти поля относятся
+        # к связанной таблице
+        fields_prefixed = [f"p.{field}" for field in fields]
+        fields_select_stmt = ", ".join(fields_prefixed)
+
+        stmt = f"""
+        SELECT {fields_select_stmt}
+        FROM {relation_table.__table__} p
+        JOIN {many2many_table} pt ON p.id = pt.{column1}
+        JOIN {self.table} t ON pt.{column2} = t.id
+        WHERE t.id = %s
+        ORDER BY {sort} {order}
+        """
+
+        val: tuple = (id,)
+
+        if end is not None and start is not None:
+            stmt += "LIMIT %s OFFSET %s"
+            val += (end - start, start)
+        elif limit:
+            stmt += "LIMIT %s"
+            val += (limit,)
+
+        return stmt, val
+
+    def build_get_many2many_multiple(
+        self: "BuilderProtocol",
+        ids: list[int],
+        relation_table: "DotModel",
+        many2many_table: str,
+        column1: str,
+        column2: str,
+        fields: list[str] | None = None,
+        limit: int = 80,
+    ) -> tuple[str, tuple]:
+        """
+        Оптимизированная версия, когда необходимо получить сразу несколько свзяей m2m
+        у нескольких записей. Не просто один список на одну записиь.
+        А N списков на N записей.
+
+        Returns:
+            tuple[str, tuple]: SQL statement and parameter values
+        """
+        if not fields:
+            fields = relation_table.get_store_fields()
+
+        # явно указать для sql запроса что эти поля относятся
+        # к связанной таблице
+        fields_prefixed = [f"p.{field}" for field in fields]
+
+        # добавляем ид из таблицы связи для последующего маппинга записей
+        # имеется ввиду за один запрос достаются все записи для всех ид
+        # а далее в питоне для каждого ид остаются только его
+        fields_prefixed.append(f"pt.{column2} as m2m_id")
+
+        fields_select_stmt = ", ".join(fields_prefixed)
+        query_placeholders = ", ".join(["%s"] * len(ids))
+
+        stmt = f"""
+        SELECT {fields_select_stmt}
+        FROM {relation_table.__table__} p
+        JOIN {many2many_table} pt ON p.id = pt.{column1}
+        JOIN {self.table} t ON pt.{column2} = t.id
+        WHERE t.id IN ({query_placeholders})
+        LIMIT %s
+        """
+
+        val = (*ids, limit)
+        return stmt, val
+
+
+#         SELECT * FROM (
+#     SELECT p.*, pt.column2 as m2m_id,
+#            ROW_NUMBER() OVER (PARTITION BY pt.column2 ORDER BY p.id) as rn
+#     FROM relation_table p
+#     JOIN m2m_table pt ON p.id = pt.column1
+#     WHERE pt.column2 IN (%s, %s, ...)
+# ) sub WHERE rn <= {limit_per_parent}

dotorm/builder/mixins/relations.py

@@ -0,0 +1,96 @@
+"""Relations query builder."""
+
+from typing import TYPE_CHECKING, Self
+
+if TYPE_CHECKING:
+    from ..protocol import BuilderProtocol
+
+from ..request_builder import RequestBuilder
+from ...fields import Field, Many2many, Many2one, One2many
+
+
+class RelationsMixin:
+    """Mixin for relation queries."""
+
+    __slots__ = ()
+
+    def build_search_relation(
+        self: "BuilderProtocol",
+        fields_relation: list[tuple[str, Field]],
+        records: list | None = None,
+    ) -> list[RequestBuilder]:
+        """
+        Build optimized queries for loading relations.
+        Avoids N+1 by batching relation queries.
+        """
+        if records is None:
+            records = []
+
+        request_list: list[RequestBuilder] = []
+        ids: list[int] = [record.id for record in records]
+
+        if not ids:
+            return request_list
+
+        for name, field in fields_relation:
+            # Default fields for relations
+            fields = ["id"]
+            if field.relation_table and field.relation_table.get_fields().get(
+                "name"
+            ):
+                fields.append("name")
+
+            req: RequestBuilder | None = None
+
+            if isinstance(field, One2many):
+                stmt, val = field.relation_table._builder.build_search(
+                    fields=[*fields, field.relation_table_field],
+                    filter=[(field.relation_table_field, "in", ids)],
+                )
+                req = RequestBuilder(
+                    stmt=stmt,
+                    value=val,
+                    field_name=name,
+                    field=field,
+                    fields=fields,
+                )
+
+            elif isinstance(field, Many2many):
+                stmt, val = self.build_get_many2many_multiple(
+                    ids=ids,
+                    relation_table=field.relation_table,
+                    many2many_table=field.many2many_table,
+                    column1=field.column1,
+                    column2=field.column2,
+                    fields=fields,
+                )
+                req = RequestBuilder(
+                    stmt=stmt,
+                    value=val,
+                    field_name=name,
+                    field=field,
+                )
+
+            elif isinstance(field, Many2one):
+                ids_m2o: list[int] = [
+                    getattr(record, name) for record in records
+                ]
+                # оставляем только уникальные ид, так как в m2o несколько записей
+                # могут ссылаться на одну сущность
+                ids_m2o = list(set(ids_m2o))
+
+                stmt, val = field.relation_table._builder.build_search(
+                    fields=fields,
+                    filter=[("id", "in", ids_m2o)],
+                )
+                req = RequestBuilder(
+                    stmt=stmt,
+                    value=val,
+                    field_name=name,
+                    field=field,
+                )
+
+            if req:
+                request_list.append(req)
+
+        return request_list

dotorm/builder/protocol.py

@@ -0,0 +1,63 @@
+"""Protocol defining what mixins expect from the base class."""
+
+from typing import TYPE_CHECKING, Literal, Protocol, runtime_checkable
+
+from ..components.filter_parser import FilterExpression
+
+if TYPE_CHECKING:
+    from ..model import DotModel
+    from ..fields import Field
+    from ..components.dialect import Dialect
+    from ..components.filter_parser import FilterParser
+
+
+@runtime_checkable
+class BuilderProtocol(Protocol):
+    """Contract that mixins expect from the base class."""
+
+    table: str
+    fields: dict[str, "Field"]
+    dialect: "Dialect"
+    filter_parser: "FilterParser"
+
+    def get_store_fields(self) -> list[str]:
+        """Returns field names that are stored in DB."""
+        ...
+
+    def build_search(
+        self,
+        fields: list[str] | None = None,
+        start: int | None = None,
+        end: int | None = None,
+        limit: int = 80,
+        order: Literal["DESC", "ASC", "desc", "asc"] = "DESC",
+        sort: str = "id",
+        filter: FilterExpression | None = None,
+        raw: bool = False,
+    ) -> tuple[str, tuple]: ...
+
+    def build_get_many2many_multiple(
+        self: "BuilderProtocol",
+        ids: list[int],
+        relation_table: "DotModel",
+        many2many_table: str,
+        column1: str,
+        column2: str,
+        fields: list[str] | None = None,
+        limit: int = 80,
+    ) -> tuple[str, tuple]: ...
+
+    def build_get_many2many(
+        self,
+        id: int,
+        relation_table: "DotModel",
+        many2many_table: str,
+        column1: str,
+        column2: str,
+        fields: list[str],
+        order: Literal["desc", "asc"] = "desc",
+        start: int | None = None,
+        end: int | None = None,
+        sort: str = "id",
+        limit: int | None = 10,
+    ) -> tuple[str, tuple]: ...

dotorm/builder/request_builder.py

@@ -0,0 +1,144 @@
+"""Request builder for relation queries."""
+
+from __future__ import annotations
+from dataclasses import dataclass, field as d_field
+from typing import Any, Callable, ClassVar
+from enum import Enum, auto
+
+from ..fields import (
+    AttachmentMany2one,
+    AttachmentOne2many,
+    Field,
+    Many2many,
+    Many2one,
+    One2many,
+)
+
+
+class FetchMode(Enum):
+    """Database cursor fetch mode."""
+
+    FETCHALL = auto()
+    FETCHONE = auto()
+    FETCHMANY = auto()
+
+
+# Type aliases for relation fields
+RelationField = Many2many | One2many | Many2one
+FormRelationField = (
+    Many2many | One2many | Many2one | AttachmentMany2one | AttachmentOne2many
+)
+
+
+@dataclass(slots=True)
+class RequestBuilder:
+    """
+    Container for relation query request.
+
+    Immutable data container with computed properties for
+    determining how to process query results.
+    """
+
+    stmt: str | None
+    value: Any
+    field_name: str
+    field: Field
+    fields: list[str] = d_field(default_factory=lambda: ["id", "name"])
+    fetch_mode: FetchMode = FetchMode.FETCHALL
+
+    # Mapping for prepare functions based on field type
+    _PREPARE_FUNCS: ClassVar[dict[type, str]] = {
+        Many2many: "prepare_list_ids",
+        One2many: "prepare_list_ids",
+        Many2one: "prepare_list_ids",
+    }
+
+    @property
+    def function_cursor(self) -> str:
+        """Returns cursor method name based on fetch mode."""
+        return self.fetch_mode.name.lower()
+
+    @property
+    def function_prepare(self) -> Callable:
+        """
+        Returns appropriate prepare function based on field type.
+
+        For relation fields (Many2many, One2many, Many2one),
+        returns prepare_list_ids from relation_table.
+        """
+        for field_type, method_name in self._PREPARE_FUNCS.items():
+            if isinstance(self.field, field_type):
+                return getattr(self.field.relation_table, method_name)
+
+        # Fallback for non-relation fields
+        # TODO: помоему тут ошибка relation_table всегда будет пустое
+        # а реквест билдер всеравно не используется в не связей
+        # и else никогда не вызывается
+        return getattr(self.field.relation_table, "prepare_list_id")
+
+
+@dataclass(slots=True)
+class RequestBuilderForm(RequestBuilder):
+    """
+    Container for form relation query request.
+
+    Extends RequestBuilder with form-specific prepare functions.
+    """
+
+    # Override mapping for form context
+    _PREPARE_FUNCS: ClassVar[dict[type, str]] = {
+        Many2many: "prepare_form_ids",
+        One2many: "prepare_form_ids",
+        Many2one: "prepare_form_ids",
+        AttachmentMany2one: "prepare_form_ids",
+        AttachmentOne2many: "prepare_form_ids",
+    }
+
+    @property
+    def function_prepare(self) -> Callable:
+        """
+        Returns appropriate prepare function for form context.
+
+        Form context uses prepare_form_ids/prepare_form_id methods.
+        """
+        for field_type, method_name in self._PREPARE_FUNCS.items():
+            if isinstance(self.field, field_type):
+                return getattr(self.field.relation_table, method_name)
+
+        return getattr(self.field.relation_table, "prepare_form_id")
+
+
+def create_request_builder(
+    stmt: str | None,
+    value: Any,
+    field_name: str,
+    field: Field,
+    fields: list[str] | None = None,
+    *,
+    form_mode: bool = False,
+) -> RequestBuilder:
+    """
+    Factory function for creating appropriate RequestBuilder.
+
+    Args:
+        stmt: SQL statement
+        value: Query parameters
+        field_name: Name of the field
+        field: Field instance
+        fields: Fields to select (default: ["id", "name"])
+        form_mode: If True, creates RequestBuilderForm
+
+    Returns:
+        RequestBuilder or RequestBuilderForm instance
+    """
+    if fields is None:
+        fields = ["id", "name"]
+
+    cls = RequestBuilderForm if form_mode else RequestBuilder
+    return cls(
+        stmt=stmt,
+        value=value,
+        field_name=field_name,
+        field=field,
+        fields=fields,
+    )

dotorm/components/__init__.py

@@ -0,0 +1,18 @@
+"""
+Extracted components for cleaner architecture.
+
+These components can be used standalone or by existing ORM classes.
+"""
+
+from .dialect import Dialect, POSTGRES, MYSQL, get_dialect
+from .filter_parser import FilterParser, FilterExpression, FilterTriplet
+
+__all__ = [
+    "Dialect",
+    "POSTGRES",
+    "MYSQL",
+    "get_dialect",
+    "FilterParser",
+    "FilterExpression",
+    "FilterTriplet",
+]

dotorm/components/dialect.py

@@ -0,0 +1,99 @@
+"""
+Database dialect definitions.
+
+Centralizes all dialect-specific logic in one place.
+"""
+
+from dataclasses import dataclass
+from typing import Literal
+
+
+@dataclass(frozen=True)
+class Dialect:
+    """
+    Database dialect configuration.
+
+    Contains all dialect-specific settings:
+    - name: dialect identifier
+    - escape: character for escaping identifiers ("` for MySQL, " for Postgres)
+    - placeholder: parameter placeholder style (%s for MySQL, $N for Postgres)
+    - supports_returning: whether INSERT ... RETURNING is supported
+    """
+
+    name: Literal["postgres", "mysql", "clickhouse"]
+    escape: str
+    placeholder: str
+    supports_returning: bool
+
+    def escape_identifier(self, identifier: str) -> str:
+        """Escape a column/table name."""
+        return f"{self.escape}{identifier}{self.escape}"
+
+    def make_placeholders(self, count: int, start: int = 1) -> str:
+        """
+        Generate placeholder string for given count of parameters.
+
+        For MySQL: %s, %s, %s
+        For Postgres: $1, $2, $3
+        For Clickhouse: %s, %s, %s
+        """
+        if self.name == "postgres":
+            return ", ".join(f"${i}" for i in range(start, start + count))
+        else:
+            return ", ".join(["%s"] * count)
+
+    def make_placeholder(self, index: int = 1) -> str:
+        """Generate single placeholder."""
+        if self.name == "postgres":
+            return f"${index}"
+        return "%s"
+
+    def get_no_transaction_session(self):
+        """Get appropriate session class for this dialect."""
+        if self.name == "postgres":
+            from ..databases.postgres.session import NoTransactionSession
+
+            return NoTransactionSession
+        elif self.name == "mysql":
+            from ..databases.mysql.session import NoTransactionSession
+
+            return NoTransactionSession
+        else:
+            from ..databases.clickhouse.session import NoTransactionSession
+
+            return NoTransactionSession
+
+
+# Pre-defined dialects
+POSTGRES = Dialect(
+    name="postgres",
+    escape='"',
+    placeholder="$",
+    supports_returning=True,
+)
+
+MYSQL = Dialect(
+    name="mysql",
+    escape="`",
+    placeholder="%s",
+    supports_returning=False,
+)
+
+CLICKHOUSE = Dialect(
+    name="clickhouse",
+    escape="`",
+    placeholder="%s",
+    supports_returning=False,
+)
+
+
+def get_dialect(name: str) -> Dialect:
+    """Get dialect by name."""
+    if name == "postgres":
+        return POSTGRES
+    elif name == "mysql":
+        return MYSQL
+    elif name == "clickhouse":
+        return CLICKHOUSE
+    else:
+        raise ValueError(f"Unknown dialect: {name}")