ormlambda 3.35.3__py3-none-any.whl → 4.0.4__py3-none-any.whl

ormlambda/statements/query_builder.py

@@ -1,163 +1,331 @@
 from __future__ import annotations
-from typing import Iterable, TypedDict, Optional, TYPE_CHECKING
+from typing import Callable, Generator, Optional, TYPE_CHECKING, Iterable, overload, Concatenate
+from ormlambda.sql.clause_info import IAggregate
+from ormlambda.sql.clauses import (
+    Select,
+    Where,
+    Having,
+    Order,
+    GroupBy,
+    Limit,
+    Offset,
+    JoinSelector,
+)
 
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
-from ormlambda.sql.clauses import JoinSelector
-from ormlambda import ForeignKey
-
-from ormlambda.common.interfaces import IQuery
-
-
-from ormlambda.sql.clause_info import ClauseInfo
 
 if TYPE_CHECKING:
-    from ..sql.clauses import Limit as Limit
-    from ..sql.clauses import Offset as Offset
-    from ..sql.clauses import Order as Order
-    from ..sql.clauses import Select as Select
-
-    from ..sql.clauses import GroupBy as GroupBy
-
     from ormlambda.dialects import Dialect
+    from ormlambda import Count
+
+from ormlambda import ColumnProxy, TableProxy
 
-from ..sql.clauses import Where as Where
-from ..sql.clauses import Having as Having
 from ormlambda.common.enums import JoinType
 from ormlambda.sql.elements import ClauseElement
+from ormlambda.common.interfaces import IQuery
+
+# =============================================================================
+# CLEAN QUERY COMPONENTS
+# =============================================================================
+
+
+class QueryComponents:
+    """Clean storage for all query components"""
+
+    __slots__ = (
+        "select",
+        "where",
+        "having",
+        "order",
+        "group_by",
+        "limit",
+        "offset",
+        "joins",
+        "count",
+    )
+
+    def __init__(
+        self,
+    ):
+        self.select: Optional[Select] = None
+        self.where: Optional[Where] = None
+        self.having: Optional[Having] = None
+        self.order: Optional[Order] = None
+        self.group_by: Optional[GroupBy] = None
+        self.limit: Optional[Limit] = None
+        self.offset: Optional[Offset] = None
+        self.joins: Optional[set[JoinSelector]] = {}
+        self.count: Optional[Count] = None
 
+    def clear(self) -> None:
+        """Reset all components"""
 
-class OrderType(TypedDict):
-    Select: Select
-    JoinSelector: JoinSelector
-    Where: Where
-    Order: Order
-    GroupBy: GroupBy
-    Having: Having
-    Limit: Limit
-    Offset: Offset
+        for att_name in self.__slots__:
+            # We can restore those cases that are different of None
+            if att_name == "joins":
+                setattr(self, att_name, set())
+            else:
+                setattr(self, att_name, None)
 
 
-class QueryBuilder(IQuery):
-    __order__: tuple[str, ...] = ("Select", "JoinSelector", "Where", "GroupBy", "Having", "Order", "Limit", "Offset")
+# =============================================================================
+# QUERY COMPILER INTERFACE
+# =============================================================================
 
-    def __init__(self, dialect: Dialect, by: JoinType = JoinType.INNER_JOIN):
+
+class StandardSQLCompiler:
+    """Standard SQL compiler"""
+
+    def __init__(self, dialect: Dialect):
         self.dialect = dialect
-        self._context = ClauseInfoContext()
-        self._query_list: OrderType = {}
-        self._by = by
-
-        self._joins: Optional[IQuery] = None
-        self._select: Optional[IQuery] = None
-        self._where: Optional[IQuery] = None
-        self._order: Optional[IQuery] = None
-        self._group_by: Optional[IQuery] = None
-        self._limit: Optional[IQuery] = None
-        self._offset: Optional[IQuery] = None
-
-    def add_statement[T](self, clause: ClauseInfo[T]):
-        self.update_context(clause)
-        self._query_list[type(clause).__name__] = clause
 
-    @property
-    def by(self) -> JoinType:
-        return self._by
+    def compile(self, components: QueryComponents, joins: set[JoinSelector]) -> str:
+        """Compile all components into final SQL"""
+        query_parts = []
 
-    @by.setter
-    def by(self, value: JoinType) -> None:
-        self._by = value
+        # SELECT
+        if components.select:
+            query_parts.append(components.select.compile(self.dialect).string)
 
-    @property
-    def JOINS(self) -> Optional[set[JoinSelector]]:
-        return self._joins
+        # JOINs
+        joins_sql = self._compile_joins(joins)
+        if joins_sql:
+            query_parts.append(joins_sql)
 
-    @property
-    def SELECT(self) -> ClauseElement:
-        return self._query_list.get("Select", None)
+        # WHERE
+        if components.where:
+            query_parts.append(components.where.compile(self.dialect).string)
 
-    @property
-    def WHERE(self) -> ClauseElement:
-        where = self._query_list.get("Where", None)
-        if not isinstance(where, Iterable):
-            if not where:
-                return ()
-            return (where,)
-        return where
+        # GROUP BY
+        if components.group_by:
+            query_parts.append(components.group_by.compile(self.dialect).string)
 
-    @property
-    def ORDER(self) -> ClauseElement:
-        return self._query_list.get("Order", None)
+        # HAVING
+        if components.having:
+            query_parts.append(components.having.compile(self.dialect).string)
 
-    @property
-    def GROUP_BY(self) -> ClauseElement:
-        return self._query_list.get("GroupBy", None)
+        # ORDER BY
+        if components.order:
+            query_parts.append(components.order.compile(self.dialect).string)
 
-    @property
-    def HAVING(self) -> ClauseElement:
-        where = self._query_list.get("Having", None)
-        if not isinstance(where, Iterable):
-            if not where:
-                return ()
-            return (where,)
-        return where
+        # LIMIT
+        if components.limit:
+            query_parts.append(components.limit.compile(self.dialect).string)
 
-    @property
-    def LIMIT(self) -> ClauseElement:
-        return self._query_list.get("Limit", None)
+        # OFFSET
+        if components.offset:
+            query_parts.append(components.offset.compile(self.dialect).string)
 
-    @property
-    def OFFSET(self) -> ClauseElement:
-        return self._query_list.get("Offset", None)
-
-    def query(self, dialect: Dialect, **kwargs) -> str:
-        # COMMENT: (select.query, query)We must first create an alias for 'FROM' and then define all the remaining clauses.
-        # This order is mandatory because it adds the clause name to the context when accessing the .query property of 'FROM'
-
-        extract_joins = self.pop_tables_and_create_joins_from_ForeignKey(self._by)
-
-        JOINS = self.stringify_foreign_key(extract_joins, " ")
-        query_list: tuple[str, ...] = (
-            self.SELECT.compile(dialect).string,
-            JOINS,
-            Where.join_condition(self.WHERE, True, self._context, dialect=dialect) if self.WHERE else None,
-            self.GROUP_BY.compile(dialect).string if self.GROUP_BY else None,
-            Having.join_condition(self.HAVING, True, self._context, dialect=dialect) if self.HAVING else None,
-            self.ORDER.compile(dialect).string if self.ORDER else None,
-            self.LIMIT.compile(dialect).string if self.LIMIT else None,
-            self.OFFSET.compile(dialect).string if self.OFFSET else None,
-        )
-        return " ".join([x for x in query_list if x])
-
-    def stringify_foreign_key(self, joins: set[JoinSelector], sep: str = "\n") -> Optional[str]:
+        return " ".join(query_parts)
+
+    def _compile_joins(self, joins: set[JoinSelector]) -> Optional[str]:
+        """Compile JOIN clauses"""
         if not joins:
             return None
-        sorted_joins = JoinSelector.sort_join_selectors(joins)
-        return f"{sep}".join([join.query(self.dialect) for join in sorted_joins])
 
-    def pop_tables_and_create_joins_from_ForeignKey(self, by: JoinType = JoinType.INNER_JOIN) -> set[JoinSelector]:
-        # When we applied filters in any table that we wont select any column, we need to add manually all neccessary joins to achieve positive result.
-        if not ForeignKey.stored_calls:
+        from ormlambda.sql.clauses import JoinSelector
+
+        sorted_joins = JoinSelector.sort_joins_by_alias(joins)
+        return " ".join(join.compile(self.dialect).string for join in sorted_joins)
+
+    # =============================================================================
+    # MODERN QUERY BUILDER
+    # =============================================================================
+
+
+class ColumnIterable[T: TableProxy | ColumnProxy]:
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, iterable: Iterable[T], /) -> None: ...
+
+    def __init__(self, iterable=None):
+        self.iterable: list = iterable if iterable is not None else []
+
+    def __repr__(self):
+        return self.iterable.__repr__()
+
+    def append(self, object: T, /) -> None:
+        if isinstance(object, TableProxy):
+            self.extend(object.get_columns())
             return None
 
-        joins = set()
-        # Always it's gonna be a set of two
-        # FIXME [x]: Resolved when we get Compare object instead ClauseInfo. For instance, when we have multiples condition using '&' or '|'
-        for fk in ForeignKey.stored_calls.copy():
-            fk = ForeignKey.stored_calls.pop(fk)
-            fk_alias = fk.get_alias(self.dialect)
-            self._context._add_table_alias(fk.tright, fk_alias)
-            join = JoinSelector(fk.resolved_function(self._context), by, context=self._context, alias=fk_alias, dialect=self.dialect)
-            joins.add(join)
+        return self.iterable.append(object)
 
-        return joins
+    def extend(self, iterable: Iterable[T], /) -> None:
+        for item in iterable:
+            if isinstance(item, TableProxy):
+                self.iterable.extend(item.get_columns())
+            else:
+                self.iterable.append(item)
+        return None
 
     def clear(self) -> None:
-        self.__init__(self.dialect, self.by)
+        return self.iterable.clear()
+
+    def __iter__(self) -> Generator[ColumnProxy, None, None]:
+        yield from self.iterable
+
+    def __len__(self) -> int:
+        return len(self.iterable)
+
+    def __getitem__(self, index: int) -> T:
+        return self.iterable[index]
+
+
+def call_used_column[T, **P](f: Callable[Concatenate[QueryBuilder, IAggregate, P], T]) -> Callable[Concatenate[QueryBuilder, IAggregate, P], T]:
+    def wrapped(self: QueryBuilder, aggregate: IAggregate, *args: P.args, **kwargs: P.kwargs):
+        self.used_columns.extend(aggregate.used_columns())
+        return f(self, aggregate, *args, **kwargs)
+
+    return wrapped
+
+
+class QueryBuilder(IQuery):
+    compiler: StandardSQLCompiler
+    components: QueryComponents
+    used_columns: ColumnIterable[ColumnProxy]
+    join_type: JoinType
+
+    def __init__(self):
+        # Clean component storage
+        self.components = QueryComponents()
+        self.join_type = JoinType.INNER_JOIN
+        self.used_columns = ColumnIterable()
+
+    # =============================================================================
+    # CLEAN CLAUSE MANAGEMENT
+    # =============================================================================
+
+    @call_used_column
+    def add_select(self, select: Select) -> QueryBuilder:
+        self.components.select = select
+        return self
+
+    @call_used_column
+    def add_where(self, where: Where) -> QueryBuilder:
+        if not self.components.where:
+            # we need to do that in order to initialize with our first where clause to control 'restrictive' attribute.
+            # Otherwise, we'd always has the same attribute
+            self.components.where = where
+            return self
+
+        comparer = where.comparer
+        self.components.where.add_comparers(comparer)
+        return self
+
+    @call_used_column
+    def add_having(self, having: Having) -> QueryBuilder:
+        if not self.components.having:
+            # we need to do that in order to initialize with our first having clause to control 'restrictive' attribute.
+            # Otherwise, we'd always has the same attribute
+            self.components.having = having
+            return self
+
+        comparer = having.comparer
+        self.components.having.add_comparers(comparer)
+        return self
+
+    @call_used_column
+    def add_order(self, order: Order) -> QueryBuilder:
+        self.components.order = order
+        return self
+
+    @call_used_column
+    def add_group_by(self, group_by: GroupBy) -> QueryBuilder:
+        self.components.group_by = group_by
+        return self
+
+    def add_limit(self, limit: Limit) -> QueryBuilder:
+        self.components.limit = limit
+        return self
+
+    def add_offset(self, offset: Offset) -> QueryBuilder:
+        self.components.offset = offset
+        return self
+
+    @call_used_column
+    def add_join(self, join: JoinSelector) -> QueryBuilder:
+        self.components.joins.add(join)
+        return self
+
+    @call_used_column
+    def add_count(self, count: Count) -> QueryBuilder:
+        self.components.count = count
+        return self
+
+    def set_join_type(self, join_type: JoinType) -> QueryBuilder:
+        self.join_type = join_type
+        return self
+
+    # =============================================================================
+    # GENERIC CLAUSE ADDITION (for existing code compatibility)
+    # =============================================================================
+
+    def add_statement(self, clause: ClauseElement) -> QueryBuilder:
+        """
+        Add any clause element - determines type automatically
+
+        This provides a single entry point for all clause types
+        while maintaining clean type-specific methods above
+        """
+        clause_type = type(clause).__name__
+
+        clause_selector: dict[str, Callable[[ClauseElement], QueryBuilder]] = {
+            "Select": self.add_select,
+            "Where": self.add_where,
+            "Having": self.add_having,
+            "Order": self.add_order,
+            "GroupBy": self.add_group_by,
+            "Limit": self.add_limit,
+            "Offset": self.add_offset,
+            "JoinSelector": self.add_join,
+            "Count": self.add_count,
+        }
+
+        method = clause_selector.get(clause_type, None)
+        if not method:
+            raise ValueError(f"Unknown clause type: {clause_type}")
+
+        return method(clause)
+
+    # =============================================================================
+    # QUERY GENERATION
+    # =============================================================================
+
+    def query(self, dialect: Optional[Dialect] = None) -> str:
+        # Detect required joins
+        all_joins = self.pop_tables_and_create_joins_from_ForeignKey(dialect)
+
+        # Compile to SQL
+        return StandardSQLCompiler(dialect).compile(self.components, all_joins)
+
+    def pop_tables_and_create_joins_from_ForeignKey(self, dialect) -> set[JoinSelector]:
+        # When we applied filters in any table that we wont select any column, we need to add manually all neccessary joins to achieve positive result.
+
+        joins: set[JoinSelector] = set()
+
+        join_type = self.by if self.by != JoinType.INNER_JOIN else JoinType.LEFT_INCLUSIVE
+        for column in self.used_columns:
+            if not column.number_table_in_chain():
+                continue  # It would be the same table so we don't need any join clause
+
+            temp_joins = column.get_relations(join_type, dialect)
+
+            [joins.add(x) for x in temp_joins]
+
+        sorted_joins = JoinSelector.sort_joins_by_alias(joins)
+        return sorted_joins
+
+    def clear(self) -> None:
+        """Clear all components"""
+        self.components.clear()
+        self.used_columns.clear()
         return None
 
-    def update_context(self, clause: ClauseInfo) -> None:
-        if not hasattr(clause, "context"):
-            return None
+    @property
+    def by(self) -> Optional[JoinType]:
+        return self.join_type
 
-        if clause.context is not None:
-            self._context.update(clause.context)
-        clause.context = self._context
+    @by.setter
+    def by(self, value: JoinType) -> None:
+        self.join_type = value