dotorm 2.0.8__py3-none-any.whl

dotorm/components/filter_parser.py

@@ -0,0 +1,195 @@
+"""
+SQL filter expression parser.
+
+Converts filter expressions to SQL WHERE clauses.
+Extracted to avoid code duplication in builders.
+"""
+
+from typing import Any, Literal, Union
+
+from .dialect import Dialect
+
+
+# Type definitions
+SQLOperator = Literal[
+    "=",
+    ">",
+    "<",
+    "!=",
+    ">=",
+    "<=",
+    "like",
+    "ilike",
+    "=like",
+    "=ilike",
+    "not ilike",
+    "not like",
+    "in",
+    "not in",
+    "is null",
+    "is not null",
+    "between",
+    "not between",
+]
+
+FilterTriplet = tuple[str, SQLOperator, Any]
+
+FilterExpression = list[
+    FilterTriplet
+    | tuple[Literal["not"], "FilterExpression"]
+    | list[Union["FilterExpression", Literal["and", "or"]]],
+]
+
+
+class FilterParser:
+    """
+    Parses filter expressions into SQL WHERE clauses.
+
+    Supports:
+    - Simple triplets: ("field", "=", value)
+    - NOT expressions: ("not", ("field", "=", value))
+    - Nested logic: [("a", "=", 1), "or", ("b", "=", 2)]
+    - Complex nesting with AND/OR
+
+    Example:
+        parser = FilterParser(POSTGRES)
+        clause, values = parser.parse([
+            ("active", "=", True),
+            "or",
+            [("role", "=", "admin"), ("verified", "=", True)]
+        ])
+        # clause: '"active" = $1 OR ("role" = $2 AND "verified" = $3)'
+        # values: (True, "admin", True)
+    """
+
+    def __init__(self, dialect: Dialect):
+        self.dialect = dialect
+
+    def _is_triplet(self, expr: Any) -> bool:
+        """Check if expression is a simple triplet."""
+        return (
+            isinstance(expr, (list, tuple))
+            and len(expr) == 3
+            and isinstance(expr[0], str)
+        )
+
+    def parse(self, filter_expr: FilterExpression) -> tuple[str, tuple]:
+        """Recursively parse filter expression."""
+        escape = self.dialect.escape
+
+        # NOT expression: ("not", expr)
+        if (
+            isinstance(filter_expr, (list, tuple))
+            and len(filter_expr) == 2
+            and filter_expr[0] == "not"
+        ):
+            inner_expr = filter_expr[1]
+            clause, values = self.parse(inner_expr)  # type: ignore
+            return f"NOT ({clause})", values
+
+        # Simple triplet: ("field", "op", value)
+        if self._is_triplet(filter_expr):
+            field, op, value = filter_expr
+            field = f"{escape}{field}{escape}"
+            assert isinstance(op, str)
+            op = op.lower()
+
+            if op in ("in", "not in"):
+                if not isinstance(value, (list, tuple)):
+                    raise ValueError(
+                        f"Operator '{op}' requires list/tuple value"
+                    )
+                placeholders = ", ".join(["%s"] * len(value))
+                clause = f"{field} {op.upper()} ({placeholders})"
+                return clause, tuple(value)
+
+            elif op in (
+                "like",
+                "ilike",
+                "=like",
+                "=ilike",
+                "not like",
+                "not ilike",
+            ):
+                clause = f"{field} {op.upper()} %s"
+                return clause, ("%" + str(value) + "%",)
+
+            elif op in ("=", "!=", ">", "<", ">=", "<="):
+                # None -> IS NULL / IS NOT NULL
+                if value is None:
+                    if op == "=":
+                        return f"{field} IS NULL", ()
+                    elif op == "!=":
+                        return f"{field} IS NOT NULL", ()
+                    else:
+                        raise ValueError(
+                            f"Operator '{op}' cannot be used with None"
+                        )
+                clause = f"{field} {op} %s"
+                return clause, (value,)
+
+            elif op == "is null":
+                return f"{field} IS NULL", ()
+
+            elif op == "is not null":
+                return f"{field} IS NOT NULL", ()
+
+            elif op in ("between", "not between"):
+                if not isinstance(value, (list, tuple)) or len(value) != 2:
+                    raise ValueError(
+                        f"Operator '{op}' requires list of two values"
+                    )
+                clause = f"{field} {op.upper()} %s AND %s"
+                return clause, (value[0], value[1])
+
+            else:
+                raise ValueError(f"Unsupported operator: {op}")
+
+        # Nested expression: list with possible AND/OR
+        elif isinstance(filter_expr, list):
+            parts: list[tuple[str, str, bool]] = []
+            values: list[Any] = []
+
+            i = 0
+            while i < len(filter_expr):
+                item = filter_expr[i]
+
+                if isinstance(item, (list, tuple)):
+                    clause, clause_values = self.parse(item)  # type: ignore
+                    wrap = not self._is_triplet(item)
+                    parts.append(("EXPR", clause, wrap))
+                    values.extend(clause_values)
+                    i += 1
+
+                elif isinstance(item, str) and item.lower() in ("and", "or"):
+                    parts.append(("OP", item.upper(), False))
+                    i += 1
+
+                else:
+                    raise ValueError(
+                        f"Invalid filter element at position {i}: {item}"
+                    )
+
+            # Auto-insert AND between consecutive expressions
+            normalized: list[tuple[str, str, bool]] = []
+            for idx, part in enumerate(parts):
+                if (
+                    idx > 0
+                    and part[0] == "EXPR"
+                    and parts[idx - 1][0] == "EXPR"
+                ):
+                    normalized.append(("OP", "AND", False))
+                normalized.append(part)
+
+            sql_parts: list[str] = []
+            for part in normalized:
+                kind, content, wrap = part
+                if kind == "EXPR":
+                    sql_parts.append(f"({content})" if wrap else content)
+                elif kind == "OP":
+                    sql_parts.append(content)
+
+            return " ".join(sql_parts), tuple(values)
+
+        else:
+            raise ValueError("Unsupported filter expression format")

dotorm/databases/__init__.py

@@ -0,0 +1,13 @@
+"""Database drivers."""
+
+from .abstract import (
+    ContainerSettings,
+    PostgresPoolSettings,
+    MysqlPoolSettings,
+)
+
+__all__ = [
+    "ContainerSettings",
+    "PostgresPoolSettings",
+    "MysqlPoolSettings",
+]

dotorm/databases/abstract/__init__.py

@@ -0,0 +1,25 @@
+"""Abstract database interfaces."""
+
+from .pool import PoolAbstract
+from .session import SessionAbstract
+from .dialect import Dialect, PostgresDialect, MySQLDialect, ClickHouseDialect, CursorType
+from .types import (
+    ContainerSettings,
+    PostgresPoolSettings,
+    MysqlPoolSettings,
+    ClickhousePoolSettings,
+)
+
+__all__ = [
+    "PoolAbstract",
+    "SessionAbstract",
+    "Dialect",
+    "PostgresDialect",
+    "MySQLDialect",
+    "ClickHouseDialect",
+    "CursorType",
+    "ContainerSettings",
+    "PostgresPoolSettings",
+    "MysqlPoolSettings",
+    "ClickhousePoolSettings",
+]

dotorm/databases/abstract/dialect.py

@@ -0,0 +1,134 @@
+"""Database dialect abstraction (Strategy pattern)."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Literal
+
+
+# Unified cursor types for all dialects
+CursorType = Literal[
+    "fetchall",
+    "fetch",
+    "fetchrow",
+    "fetchval",
+    "executemany",
+    "lastrowid",  # MySQL-specific
+    "void",  # Execute without returning results
+]
+
+
+class Dialect(ABC):
+    """
+    Abstract dialect defining database-specific behavior.
+
+    Each database has its own dialect that handles:
+    - Placeholder conversion (%s → $1 for Postgres, %s stays for MySQL)
+    - Cursor method mapping (fetchall → fetch for asyncpg)
+    - Result conversion (Record → dict)
+    """
+
+    _cursor_map: dict[str, str]
+
+    def convert_placeholders(self, stmt: str) -> str:
+        """Convert %s placeholders to database-specific format."""
+        return stmt
+
+    def get_cursor_method(self, cursor: CursorType) -> str:
+        """Map CursorType to actual driver method name."""
+        return self._cursor_map.get(cursor, "void")
+
+    @abstractmethod
+    def convert_result(self, rows: Any, cursor: CursorType) -> Any:
+        """Convert raw database result to standard format (list of dicts, etc)."""
+        ...
+
+
+class PostgresDialect(Dialect):
+    """PostgreSQL dialect for asyncpg driver."""
+
+    _cursor_map = {
+        "fetchall": "fetch",
+        "fetch": "fetch",
+        "fetchrow": "fetchrow",
+        "fetchval": "fetchval",
+    }
+
+    def convert_placeholders(self, stmt: str) -> str:
+        """Convert %s to $1, $2, $3..."""
+        counter = 1
+        while "%s" in stmt:
+            stmt = stmt.replace("%s", f"${counter}", 1)
+            counter += 1
+        return stmt
+
+    def convert_result(self, rows: Any, cursor: CursorType) -> Any:
+        """Convert asyncpg Record objects to dicts."""
+        if rows is None or cursor in ("void", "executemany"):
+            return rows
+
+        if cursor == "fetchval":
+            return rows  # Single value
+
+        if cursor == "fetchrow":
+            return dict(rows) if rows else None
+
+        # fetchall/fetch
+        return [dict(rec) for rec in rows] if rows else []
+
+
+class MySQLDialect(Dialect):
+    """MySQL dialect for aiomysql driver."""
+
+    _cursor_map = {
+        "fetchall": "fetchall",
+        "fetch": "fetchall",
+        "fetchrow": "fetchone",
+        "fetchval": "fetchone",
+    }
+
+    def convert_result(self, rows: Any, cursor: CursorType) -> Any:
+        """Convert MySQL results."""
+        if rows is None or cursor in ("void", "executemany", "lastrowid"):
+            return rows
+
+        if cursor == "fetchval":
+            # fetchone returns tuple, get first element
+            return (
+                rows[0] if rows and isinstance(rows, (tuple, list)) else rows
+            )
+
+        if cursor == "fetchrow":
+            return dict(rows) if rows else None
+
+        # fetchall/fetch
+        return [dict(rec) for rec in rows] if rows else []
+
+
+class ClickHouseDialect(Dialect):
+    """ClickHouse dialect for asynch driver."""
+
+    _cursor_map = {
+        "fetchall": "fetchall",
+        "fetch": "fetchall",
+        "fetchrow": "fetchone",
+        "fetchval": "fetchone",
+    }
+
+    def convert_result(self, rows: Any, cursor: CursorType) -> Any:
+        """Convert ClickHouse results to dicts."""
+        if rows is None or cursor in ("void", "executemany"):
+            return rows
+
+        if cursor == "fetchval":
+            # fetchone returns tuple, get first element
+            if rows and isinstance(rows, (tuple, list)):
+                return rows[0]
+            return rows
+
+        if cursor == "fetchrow":
+            # Single row - convert to dict if tuple with column info
+            return dict(rows) if rows and hasattr(rows, "_fields") else rows
+
+        # fetchall/fetch - list of tuples
+        if rows and hasattr(rows[0], "_fields"):
+            return [dict(rec._asdict()) for rec in rows]
+        return rows if rows else []

dotorm/databases/abstract/pool.py

@@ -0,0 +1,10 @@
+"""Abstract pool interface."""
+
+from abc import ABC, abstractmethod
+
+
+class PoolAbstract(ABC):
+    @abstractmethod
+    async def create_pool(
+        self,
+    ): ...

dotorm/databases/abstract/session.py

@@ -0,0 +1,67 @@
+"""Abstract session interface."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .dialect import CursorType
+
+
+class SessionAbstract(ABC):
+    """
+    Abstract database session.
+
+    Subclasses must implement execute() method.
+    Use dialect helper for SQL transformations.
+    """
+
+    @abstractmethod
+    async def execute(
+        self,
+        stmt: str,
+        values: Any = None,
+        *,
+        prepare: Callable | None = None,
+        cursor: "CursorType" = "fetchall",
+    ) -> Any:
+        """
+        Execute SQL query.
+
+        Args:
+            stmt: SQL statement with %s placeholders
+            values: Query parameters:
+                - Tuple/list for single query
+                - List of tuples for executemany
+            prepare: Optional function to transform results
+            cursor: Fetch mode:
+                - "fetchall"/"fetch": Return list of dicts
+                - "fetchrow": Return single dict or None
+                - "fetchval": Return single value or None
+                - "executemany": Execute multiple inserts
+                - "lastrowid": Return last inserted row ID (MySQL only)
+                - "void": Execute without returning rows (INSERT/UPDATE/DELETE)
+
+        Returns:
+            Query results based on cursor mode
+
+        Example:
+            # Fetch all rows
+            rows = await session.execute("SELECT * FROM users WHERE active = %s", (True,))
+
+            # Fetch single row
+            user = await session.execute("SELECT * FROM users WHERE id = %s", (1,), cursor="fetchrow")
+
+            # Fetch single value
+            count = await session.execute("SELECT COUNT(*) FROM users", cursor="fetchval")
+
+            # Execute without return
+            await session.execute("UPDATE users SET active = %s", (False,), cursor="void")
+
+            # Execute many
+            await session.execute(
+                "INSERT INTO users (name) VALUES (%s)",
+                [("Alice",), ("Bob",)],
+                cursor="executemany"
+            )
+        """
+        ...

dotorm/databases/abstract/types.py

@@ -0,0 +1,36 @@
+"""Database configuration types."""
+
+from typing import Literal
+from pydantic_settings import BaseSettings
+
+
+class ContainerSettings(BaseSettings):
+    reconnect_timeout: int = 10
+    driver: Literal["asynch", "aiomysql", "asyncpg"]
+    ssl: str = ""
+    sync_db: bool = False
+
+
+class PostgresPoolSettings(BaseSettings):
+    host: str
+    port: int
+    user: str
+    password: str
+    database: str
+
+
+class ClickhousePoolSettings(BaseSettings):
+    host: str
+    port: int
+    user: str
+    password: str
+    database: str
+
+
+# настройки драйвера для mysql отличаются
+class MysqlPoolSettings(BaseSettings):
+    host: str
+    port: int
+    user: str
+    password: str
+    db: str

dotorm/databases/clickhouse/__init__.py

@@ -0,0 +1,8 @@
+"""ClickHouse database support."""
+
+from .session import ClickhouseSession, NoTransactionSession
+
+__all__ = [
+    "ClickhouseSession",
+    "NoTransactionSession",
+]

dotorm/databases/clickhouse/pool.py

@@ -0,0 +1,60 @@
+import asyncio
+import logging
+import time
+
+try:
+    import asynch
+except ImportError:
+    ...
+
+from ..abstract.types import (
+    ClickhousePoolSettings,
+    ContainerSettings,
+)
+
+log = logging.getLogger(__package__)
+
+
+class ContainerClickhouse:
+    def __init__(
+        self,
+        pool_settings: ClickhousePoolSettings,
+        container_settings: ContainerSettings,
+    ):
+        self.pool_settings = pool_settings
+        self.container_settings = container_settings
+
+    async def create_pool(self):
+        try:
+            start_time: float = time.time()
+            pool = await asynch.create_pool(
+                **self.pool_settings.model_dump(),
+                min_size=5,
+                max_size=15,
+                # command_timeout=60,
+                # 15 minutes
+                # max_inactive_connection_lifetime
+                # pool_recycle=60 * 15,
+            )
+            assert isinstance(pool, asynch.Pool)
+            assert pool is not None
+            self.pool = pool
+            start_time: float = time.time()
+
+            log.debug(
+                "Connection Clickhouse db: %s, created time: [%0.3fs]",
+                self.pool_settings.database,
+                time.time() - start_time,
+            )
+            return self.pool
+        except (ConnectionError, TimeoutError):
+            # Если не смогли подключиться к базе пробуем переподключиться
+            log.exception(
+                "Clickhouse create poll connection lost, reconnect after 10 seconds: "
+            )
+            await asyncio.sleep(self.container_settings.reconnect_timeout)
+            await self.create_pool()
+        except Exception as e:
+            # если ошибка не связанна с сетью, завершаем выполнение программы
+            log.exception("Clickhouse create pool error:")
+            raise e

dotorm/databases/clickhouse/session.py

@@ -0,0 +1,100 @@
+"""ClickHouse session implementations."""
+
+from typing import Any, Callable, TYPE_CHECKING
+
+from ..abstract.session import SessionAbstract
+from ..abstract.dialect import ClickHouseDialect, CursorType
+
+
+if TYPE_CHECKING:
+    import asynch
+    from asynch.cursors import Cursor
+
+
+# Shared dialect instance
+_dialect = ClickHouseDialect()
+
+
+class ClickhouseSession(SessionAbstract):
+    """Base ClickHouse session."""
+
+    @staticmethod
+    async def _do_execute(
+        cursor: "Cursor",
+        stmt: str,
+        values: Any,
+        cursor_type: CursorType,
+    ) -> Any:
+        """
+        Execute query on cursor (shared logic).
+
+        Args:
+            cursor: asynch cursor
+            stmt: SQL with %s placeholders
+            values: Query values
+            cursor_type: Cursor type
+
+        Returns:
+            Raw result from asynch
+        """
+        # executemany
+        if cursor_type == "executemany":
+            if not values:
+                raise ValueError("executemany requires values")
+            for row in values:
+                await cursor.execute(stmt, row)
+            return None
+
+        # Execute query
+        if values:
+            await cursor.execute(stmt, values)
+        else:
+            await cursor.execute(stmt)
+
+        # void - execute only (INSERT without return)
+        if cursor_type == "void":
+            return None
+
+        # fetch operations
+        method_name = _dialect.get_cursor_method(cursor_type)
+        if method_name:
+            method = getattr(cursor, method_name)
+            return await method()
+        return None
+
+
+class NoTransactionSession(ClickhouseSession):
+    """
+    Session for non-transactional queries.
+    Acquires connection from pool per query.
+
+    Note: ClickHouse doesn't support transactions.
+    """
+
+    default_pool: "asynch.Pool | None" = None
+
+    def __init__(self, pool: "asynch.Pool | None" = None) -> None:
+        if pool is None:
+            assert self.default_pool is not None
+            self.pool = self.default_pool
+        else:
+            self.pool = pool
+
+    async def execute(
+        self,
+        stmt: str,
+        values: Any = None,
+        *,
+        prepare: Callable | None = None,
+        cursor: CursorType = "fetchall",
+    ) -> Any:
+        stmt = _dialect.convert_placeholders(stmt)
+
+        async with self.pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                result = await self._do_execute(cur, stmt, values, cursor)
+                result = _dialect.convert_result(result, cursor)
+
+                if prepare and result:
+                    return prepare(result)
+                return result

dotorm/databases/mysql/__init__.py

@@ -0,0 +1,13 @@
+"""MySQL database support."""
+
+from .pool import ContainerMysql
+from .session import MysqlSession, TransactionSession, NoTransactionSession
+from .transaction import ContainerTransaction
+
+__all__ = [
+    "ContainerMysql",
+    "MysqlSession",
+    "TransactionSession",
+    "NoTransactionSession",
+    "ContainerTransaction",
+]