ormlambda 3.11.2__py3-none-any.whl → 3.34.0__py3-none-any.whl

ormlambda/statements/interfaces/IStatements.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 from typing import Any, Callable, Optional, Type, overload, TYPE_CHECKING
 from enum import Enum
-from abc import abstractmethod, ABC
-
+from abc import abstractmethod
 
 
 if TYPE_CHECKING:
@@ -10,12 +9,11 @@ if TYPE_CHECKING:
     from ormlambda import Table
     from ormlambda.sql.clause_info import IAggregate
     from ormlambda.sql.types import TupleJoinType, ColumnType
-    from ormlambda.databases.my_sql.join_context import JoinContext
+    from ormlambda.sql.clauses.join import JoinContext
     from ormlambda.common.enums import JoinType
     from ormlambda.sql.clause_info import ClauseInfo
     from ormlambda.sql.types import AliasType
 
-
 from ..types import (
     OrderTypes,
     Tuple,
@@ -32,12 +30,16 @@ from ..types import (
     WhereTypes,
     SelectCols,
 )
+from ormlambda.sql.elements import Element
 
 
-class IStatements[T: Table](ABC):
+class IStatements[T: Table](Element):
     @abstractmethod
     def create_table(self, if_exists: TypeExists = "fail") -> None: ...
 
+    @abstractmethod
+    def drop_table(self) -> None: ...
+
     # #TODOL [ ]: We must to implement this mehtod
     # @abstractmethod
     # def drop_table(self)->None: ...
@@ -249,33 +251,33 @@ class IStatements[T: Table](ABC):
     # @overload
     # def select[TFlavour](self, selector: Optional[Callable[[T], tuple]] = ..., *, cast_to_tuple: bool = ..., flavour: Type[TFlavour], by: Optional[Enum] = ..., **kwargs) -> TFlavour: ...
     @overload
-    def select[TRes](self, selector: SelectorFlavourType[T, TRes] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., **kwargs) -> tuple[TRes, ...]: ...
+    def select[TRes](self, selector: SelectorFlavourType[T, TRes] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> tuple[TRes, ...]: ...
     @overload
-    def select[*TRes](self, selector: SelectorFlavourType[T, tuple[*TRes]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., **kwargs) -> tuple[tuple[*TRes]]: ...
+    def select[*TRes](self, selector: SelectorFlavourType[T, tuple[*TRes]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> tuple[tuple[*TRes]]: ...
     @overload
-    def select[TFlavour](self, selector: SelectorFlavourType[T, tuple] = ..., *, flavour: Type[TFlavour], by: Optional[Enum] = ..., **kwargs) -> tuple[TFlavour, ...]: ...
+    def select[TFlavour](self, selector: SelectorFlavourType[T, tuple] = ..., *, flavour: Type[TFlavour], by: Optional[Enum] = ..., alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> tuple[TFlavour, ...]: ...
 
     @abstractmethod
-    def select[TValue, TFlavour, P](self, selector: SelectorFlavourType[T, tuple[TValue, P]] = ..., *, cast_to_tuple: bool = ..., flavour: Type[TFlavour] = ..., by: JoinType = ..., **kwargs): ...
+    def select[TValue, TFlavour, P](self, selector: SelectorFlavourType[T, tuple[TValue, P]] = ..., *, cast_to_tuple: bool = ..., flavour: Type[TFlavour] = ..., by: JoinType = ..., alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs): ...
 
     # endregion
     # region select_one
     @overload
     def select_one(self) -> T: ...
     @overload
-    def select_one[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def select_one[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> TFlavour: ...
     @overload
     def select_one[T1](self, selector: SelectorOneType[T, T1 | tuple[T1]], *, by: Optional[Enum] = ...) -> T1: ...
     @overload
     def select_one[*TRes](self, selector: SelectorOneType[T, tuple[*TRes]], *, by: Optional[Enum] = ...) -> tuple[*TRes]: ...
     @overload
-    def select_one[T1](self, selector: SelectorOneType[T, tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, **kwargs) -> T1: ...
+    def select_one[T1](self, selector: SelectorOneType[T, tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> T1: ...
     @overload
-    def select_one[T1, TFlavour](self, selector: SelectorOneType[T, T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def select_one[T1, TFlavour](self, selector: SelectorOneType[T, T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> TFlavour: ...
     @overload
-    def select_one[*TRest](self, selector: SelectorOneType[T, tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], **kwargs) -> tuple[*TRest]: ...
+    def select_one[*TRest](self, selector: SelectorOneType[T, tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> tuple[*TRest]: ...
     @overload
-    def select_one[TFlavour](self, selector: SelectorOneType[T, tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def select_one[TFlavour](self, selector: SelectorOneType[T, tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> TFlavour: ...
     @abstractmethod
     def select_one[TValue, TFlavour, *TRest](
         self,
@@ -295,15 +297,15 @@ class IStatements[T: Table](ABC):
     @overload
     def first[*TRes](self, selector: SelectorOneType[T, tuple[*TRes]], *, by: Optional[Enum] = ...) -> tuple[*TRes]: ...
     @overload
-    def first[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def first[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> TFlavour: ...
     @overload
-    def first[T1](self, selector: SelectorOneType[T, tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, **kwargs) -> T1: ...
+    def first[T1](self, selector: SelectorOneType[T, tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type, alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> T1: ...
     @overload
-    def first[T1, TFlavour](self, selector: SelectorOneType[T, T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def first[T1, TFlavour](self, selector: SelectorOneType[T, T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> TFlavour: ...
     @overload
-    def first[*TRest](self, selector: SelectorOneType[T, tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], **kwargs) -> tuple[*TRest]: ...
+    def first[*TRest](self, selector: SelectorOneType[T, tuple[*TRest]], *, by: Optional[Enum] = ..., flavour: Type[tuple], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> tuple[*TRest]: ...
     @overload
-    def first[TFlavour](self, selector: SelectorOneType[T, tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], **kwargs) -> TFlavour: ...
+    def first[TFlavour](self, selector: SelectorOneType[T, tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour], alias: Optional[AliasType[ClauseInfo[T]]] = ..., **kwargs) -> TFlavour: ...
     @abstractmethod
     def first[TValue, TFlavour, *TRest](
         self,
@@ -316,13 +318,17 @@ class IStatements[T: Table](ABC):
     # endregion
 
     # region groupby
+    @overload
+    def groupby[TRepo](self, column: list[SelectCols[T, TRepo]]) -> IStatements[T]: ...
+    @overload
+    def groupby[TRepo](self, column: SelectCols[T, TRepo]) -> IStatements[T]: ...
     @abstractmethod
-    def groupby[TRepo](self, column: Callable[[T], TRepo]) -> IStatements[T]: ...
+    def groupby[TRepo](self, column: list[SelectCols[T, TRepo]] | SelectCols[T, TRepo]) -> IStatements[T]: ...
 
     # endregion
 
     @abstractmethod
-    def alias[TProp](self, column: ColumnType[TProp], alias: AliasType[ClauseInfo[T]]) -> ClauseInfo[T]: ...
+    def alias[TProp](self, column: SelectCols[T, TProp], alias: AliasType[ClauseInfo[T]]) -> ClauseInfo[T]: ...
 
 
 class IStatements_two_generic[T, TPool](IStatements[T]):
@@ -331,6 +337,7 @@ class IStatements_two_generic[T, TPool](IStatements[T]):
     def repository(self) -> BaseRepository[TPool]: ...
 
     @property
+    @abstractmethod
     def query(self) -> str: ...
 
     @property

ormlambda/statements/query_builder.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+from typing import Iterable, TypedDict, Optional, TYPE_CHECKING
+
+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 ..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
+
+
+class OrderType(TypedDict):
+    Select: Select
+    JoinSelector: JoinSelector
+    Where: Where
+    Order: Order
+    GroupBy: GroupBy
+    Having: Having
+    Limit: Limit
+    Offset: Offset
+
+
+class QueryBuilder(IQuery):
+    __order__: tuple[str, ...] = ("Select", "JoinSelector", "Where", "GroupBy", "Having", "Order", "Limit", "Offset")
+
+    def __init__(self, dialect: Dialect, by: JoinType = JoinType.INNER_JOIN):
+        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
+
+    @by.setter
+    def by(self, value: JoinType) -> None:
+        self._by = value
+
+    @property
+    def JOINS(self) -> Optional[set[JoinSelector]]:
+        return self._joins
+
+    @property
+    def SELECT(self) -> ClauseElement:
+        return self._query_list.get("Select", None)
+
+    @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
+
+    @property
+    def ORDER(self) -> ClauseElement:
+        return self._query_list.get("Order", None)
+
+    @property
+    def GROUP_BY(self) -> ClauseElement:
+        return self._query_list.get("GroupBy", None)
+
+    @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
+
+    @property
+    def LIMIT(self) -> ClauseElement:
+        return self._query_list.get("Limit", None)
+
+    @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]:
+        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:
+            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 joins
+
+    def clear(self) -> None:
+        self.__init__(self.dialect, self.by)
+        return None
+
+    def update_context(self, clause: ClauseInfo) -> None:
+        if not hasattr(clause, "context"):
+            return None
+
+        if clause.context is not None:
+            self._context.update(clause.context)
+        clause.context = self._context