ormlambda 2.9.0__py3-none-any.whl → 2.9.4__py3-none-any.whl

ormlambda/common/interfaces/IStatements.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Any, Callable, Iterable, Optional, Literal, Type, Union, overload, TYPE_CHECKING, TypeVar
+from typing import Any, Callable, Iterable, Optional, Literal, Type, Union, overload, TYPE_CHECKING
 from enum import Enum
 from abc import abstractmethod, ABC
 import enum
@@ -17,21 +17,48 @@ class OrderType(enum.Enum):
     DESC = "DESC"
 
 
-OrderTypeString = Literal["ASC", "DESC"]
+type OrderTypes = Literal["ASC", "DESC"] | OrderType | Iterable[OrderType]
+
+
+type Tuple[T] = tuple[T, ...]
+
+type SelectRes1[T1] = tuple[Tuple[T1]]
+type SelectRes2[T1, T2] = tuple[*SelectRes1[T1], Tuple[T2]]
+type SelectRes3[T1, T2, T3] = tuple[*SelectRes2[T1, T2], Tuple[T3]]
+type SelectRes4[T1, T2, T3, T4] = tuple[*SelectRes3[T1, T2, T3], Tuple[T4]]
+type SelectRes5[T1, T2, T3, T4, T5] = tuple[*SelectRes4[T1, T2, T3, T4], Tuple[T5]]
+type SelectRes6[T1, T2, T3, T4, T5, T6] = tuple[*SelectRes5[T1, T2, T3, T4, T5], Tuple[T6]]
+type SelectRes7[T1, T2, T3, T4, T5, T6, T7] = tuple[*SelectRes6[T1, T2, T3, T4, T5, T6], Tuple[T7]]
+type SelectRes8[T1, T2, T3, T4, T5, T6, T7, T8] = tuple[*SelectRes7[T1, T2, T3, T4, T5, T6, T7], Tuple[T8]]
+type SelectRes9[T1, T2, T3, T4, T5, T6, T7, T8, T9] = tuple[*SelectRes8[T1, T2, T3, T4, T5, T6, T7, T8], Tuple[T9]]
+type SelectRes10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] = tuple[*SelectRes9[T1, T2, T3, T4, T5, T6, T7, T8, T9], Tuple[T10]]
+
+
+type WhereCondition[T, T1] = Callable[[T, T1], bool]
+type JoinCondition[T, T1] = tuple[T1, WhereCondition[T, T1]]
+
+type TupleJoins1[T, T1] = tuple[JoinCondition[T, T1]]
+type TupleJoins2[T, T1, T2] = tuple[*TupleJoins1[T, T1], JoinCondition[T, T2]]
+type TupleJoins3[T, T1, T2, T3] = tuple[*TupleJoins2[T, T1, T2], JoinCondition[T, T3]]
+type TupleJoins4[T, T1, T2, T3, T4] = tuple[*TupleJoins3[T, T1, T2, T3], JoinCondition[T, T4]]
+type TupleJoins5[T, T1, T2, T3, T4, T5] = tuple[*TupleJoins4[T, T1, T2, T3, T4], JoinCondition[T, T5]]
+type TupleJoins6[T, T1, T2, T3, T4, T5, T6] = tuple[*TupleJoins5[T, T1, T2, T3, T4, T5], JoinCondition[T, T6]]
 
-OrderTypes = OrderTypeString | OrderType | Iterable[OrderType]
 
 # TODOH: This var is duplicated from 'src\ormlambda\databases\my_sql\clauses\create_database.py'
 TypeExists = Literal["fail", "replace", "append"]
 
-T = TypeVar("T")
-WhereTypes = Union[Callable[[T], bool], Iterable[Callable[[T], bool]]]
+type WhereTypes[T, *Ts] = Union[Callable[[T, *Ts], bool], Iterable[Callable[[T, *Ts], bool]]]
 
 
-class IStatements[T: Table](ABC):
+class IStatements[T, *Ts](ABC):
     @abstractmethod
     def create_table(self, if_exists: TypeExists) -> None: ...
 
+    # #TODOL [ ]: We must to implement this mehtod
+    # @abstractmethod
+    # def drop_table(self)->None: ...
+
     @abstractmethod
     def table_exists(self) -> bool: ...
 
@@ -121,15 +148,10 @@ class IStatements[T: Table](ABC):
     def delete(self, instance: Optional[T | list[T]] = ...) -> None: ...
 
     # endregion
-    # region join
-    @abstractmethod
-    def join(self, table_left: Table, table_right: Table, *, by: str) -> IStatements[T]: ...
 
-    # endregion
     # region where
-
     @overload
-    def where(self, conditions: Iterable[Callable[[T], bool]]) -> IStatements[T]:
+    def where(self, conditions: Iterable[Callable[[T, *Ts], bool]]) -> IStatements[T, *Ts]:
         """
         This method creates where clause by passing the Iterable in lambda function
         EXAMPLE
@@ -140,7 +162,7 @@ class IStatements[T: Table](ABC):
         ...
 
     @overload
-    def where(self, conditions: Callable[[T], bool], **kwargs) -> IStatements[T]:
+    def where(self, conditions: Callable[[T, *Ts], bool], **kwargs) -> IStatements[T, *Ts]:
         """
         PARAM
         -
@@ -157,7 +179,7 @@ class IStatements[T: Table](ABC):
         ...
 
     @abstractmethod
-    def where(self, conditions: WhereTypes = lambda: None, **kwargs) -> IStatements[T]: ...
+    def where(self, conditions: WhereTypes[T, *Ts] = lambda: None, **kwargs) -> IStatements[T, *Ts]: ...
 
     # endregion
     # region order
@@ -200,44 +222,68 @@ class IStatements[T: Table](ABC):
         alias: bool = ...,
         alias_name: Optional[str] = ...,
     ) -> TProp: ...
+
+    # endregion
+    # region join
+
+    @overload
+    def join[T1](self, joins: JoinCondition[T, T1]) -> IStatements[T, T1]: ...
+    @overload
+    def join[T1](self, joins: TupleJoins1[T, T1]) -> IStatements[T, T1]: ...
+    @overload
+    def join[T1, T2](self, joins: TupleJoins2[T, T1, T2]) -> IStatements[T, T1, T2]: ...
+    @overload
+    def join[T1, T2, T3](self, joins: TupleJoins3[T, T1, T2, T3]) -> IStatements[T, T1, T2, T3]: ...
+    @overload
+    def join[T1, T2, T3, T4](self, joins: TupleJoins4[T, T1, T2, T3, T4]) -> IStatements[T, T1, T2, T3, T4]: ...
+    @overload
+    def join[T1, T2, T3, T4, T5](self, joins: TupleJoins5[T, T1, T2, T3, T4, T5]) -> IStatements[T, T1, T2, T3, T4, T5]: ...
+    @overload
+    def join[T1, T2, T3, T4, T5, T6](self, joins: TupleJoins6[T, T1, T2, T3, T4, T5, T6]) -> IStatements[T, T1, T2, T3, T4, T5, T6]: ...
+
+    @abstractmethod
+    def join[*FKTables](self, joins) -> IStatements[T, *FKTables]: ...
+
     # endregion
     # region select
     @overload
-    def select(self) -> tuple[T, ...]: ...
+    def select(self) -> SelectRes1[T]: ...
     @overload
-    def select[T1](self, selector: Callable[[T], T1], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...]]: ...
+    def select[T1](self, selector: Callable[[T], T1], *, by: Optional[Enum] = ...) -> SelectRes1[T1]: ...
     @overload
-    def select[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...]]: ...
+    def select[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ...) -> SelectRes1[T1]: ...
     @overload
-    def select[T1, T2](self, selector: Callable[[T], tuple[T1, T2]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...]]: ...
+    def select[T1, T2](self, selector: Callable[[T, *Ts], tuple[T1, T2]], *, by: Optional[Enum] = ...) -> SelectRes2[T1, T2]: ...
     @overload
-    def select[T1, T2, T3](self, selector: Callable[[T], tuple[T1, T2, T3]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...]]: ...
+    def select[T1, T2, T3](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3]], *, by: Optional[Enum] = ...) -> SelectRes3[T1, T2, T3]: ...
     @overload
-    def select[T1, T2, T3, T4](self, selector: Callable[[T], tuple[T1, T2, T3, T4]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...]]: ...
+    def select[T1, T2, T3, T4](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4]], *, by: Optional[Enum] = ...) -> SelectRes4[T1, T2, T3, T4]: ...
     @overload
-    def select[T1, T2, T3, T4, T5](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...]]: ...
+    def select[T1, T2, T3, T4, T5](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4, T5]], *, by: Optional[Enum] = ...) -> SelectRes5[T1, T2, T3, T4, T5]: ...
     @overload
-    def select[T1, T2, T3, T4, T5, T6](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...]]: ...
+    def select[T1, T2, T3, T4, T5, T6](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4, T5, T6]], *, by: Optional[Enum] = ...) -> SelectRes6[T1, T2, T3, T4, T5, T6]: ...
     @overload
-    def select[T1, T2, T3, T4, T5, T6, T7](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...]]: ...
+    def select[T1, T2, T3, T4, T5, T6, T7](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4, T5, T6, T7]], *, by: Optional[Enum] = ...) -> SelectRes7[T1, T2, T3, T4, T5, T6, T7]: ...
     @overload
-    def select[T1, T2, T3, T4, T5, T6, T7, T8](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7, T8]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...], tuple[T8, ...]]: ...
+    def select[T1, T2, T3, T4, T5, T6, T7, T8](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4, T5, T6, T7, T8]], *, by: Optional[Enum] = ...) -> SelectRes8[T1, T2, T3, T4, T5, T6, T7, T8]: ...
     @overload
-    def select[T1, T2, T3, T4, T5, T6, T7, T8, T9](self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]], *, by: Optional[Enum] = ...) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...], tuple[T8, ...], tuple[T9, ...]]: ...
+    def select[T1, T2, T3, T4, T5, T6, T7, T8, T9](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]], *, by: Optional[Enum] = ...) -> SelectRes9[T1, T2, T3, T4, T5, T6, T7, T8, T9]: ...
     @overload
-    def select[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](
-        self, selector: Callable[[T], tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], *, by: Optional[Enum] = ...
-    ) -> tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...], tuple[T4, ...], tuple[T5, ...], tuple[T6, ...], tuple[T7, ...], tuple[T8, ...], tuple[T9, ...], tuple[T10, ...]]: ...
+    def select[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](self, selector: Callable[[T, *Ts], tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], *, by: Optional[Enum] = ...) -> SelectRes10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]: ...
+
     @overload
-    def select[Ts](self, selector: Optional[Callable[[T], Ts]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ...) -> tuple[Ts, ...]: ...
+    def select[TFlavour](self, selector: Optional[Callable[[T, *Ts], tuple]] = ..., *, cast_to_tuple: bool = ..., flavour: Type[TFlavour], by: Optional[Enum] = ..., **kwargs) -> TFlavour: ...
     @overload
-    def select[Ts](self, selector: Optional[Callable[[T], tuple[Ts]]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ...) -> tuple[Ts, ...]: ...
+    def select[TRes](self, selector: Optional[Callable[[T, *Ts], TRes]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., **kwargs) -> tuple[TRes, ...]: ...
     @overload
-    def select[*Ts](self, selector: Optional[Callable[[T], tuple[*Ts]]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ...) -> tuple[tuple[*Ts]]: ...
+    def select[TRes](self, selector: Optional[Callable[[T, *Ts], tuple[TRes]]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., **kwargs) -> tuple[TRes, ...]: ...
     @overload
-    def select[TFlavour](self, selector: Optional[Callable[[T], tuple]] = ..., *, flavour: Type[TFlavour], by: Optional[Enum] = ...) -> tuple[TFlavour]: ...
+    def select[*TRes](self, selector: Optional[Callable[[T, *Ts], tuple[*TRes]]] = ..., *, flavour: Type[tuple], by: Optional[Enum] = ..., **kwargs) -> tuple[tuple[*TRes]]: ...
+    @overload
+    def select[TFlavour](self, selector: Optional[Callable[[T, *Ts], tuple]] = ..., *, flavour: Type[TFlavour], by: Optional[Enum] = ..., **kwargs) -> tuple[TFlavour]: ...
+
     @abstractmethod
-    def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = ..., *, flavour: Type[TFlavour] = ..., by: JoinType = ...): ...
+    def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T, *Ts], tuple[TValue, *Ts]]] = ..., *, cast_to_tuple: bool = ..., flavour: Type[TFlavour] = ..., by: JoinType = ..., **kwargs): ...
 
     # endregion
     # region select_one
@@ -246,24 +292,24 @@ class IStatements[T: Table](ABC):
     @overload
     def select_one[TFlavour](self, *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> TFlavour: ...
     @overload
-    def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ...) -> T1: ...
+    def select_one[T1](self, selector: Callable[[T, *Ts], tuple[T1]], *, by: Optional[Enum] = ...) -> T1: ...
     @overload
-    def select_one[*Ts](self, selector: Callable[[T], tuple[*Ts]], *, by: Optional[Enum] = ...) -> tuple[*Ts]: ...
+    def select_one[*TRes](self, selector: Callable[[T, *Ts], tuple[*TRes]], *, by: Optional[Enum] = ...) -> tuple[*TRes]: ...
     @overload
-    def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type) -> T1: ...
+    def select_one[T1](self, selector: Callable[[T, *Ts], tuple[T1]], *, by: Optional[Enum] = ..., flavour: Type) -> T1: ...
     @overload
-    def select_one[T1, TFlavour](self, selector: Callable[[T], T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> T1: ...
+    def select_one[T1, TFlavour](self, selector: Callable[[T, *Ts], T1], *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> T1: ...
     @overload
-    def select_one[*Ts](self, selector: Callable[[T], tuple[*Ts]], *, by: Optional[Enum] = ..., flavour: Type[tuple]) -> tuple[*Ts]: ...
+    def select_one[*Ts](self, selector: Callable[[T, *Ts], tuple[*Ts]], *, by: Optional[Enum] = ..., flavour: Type[tuple]) -> tuple[*Ts]: ...
     @overload
-    def select_one[TFlavour](self, selector: Callable[[T], tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> TFlavour: ...
+    def select_one[TFlavour](self, selector: Callable[[T, *Ts], tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> TFlavour: ...
     @abstractmethod
-    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Type[TFlavour] = ..., by: Optional[Enum] = ...): ...
+    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T, *Ts], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Type[TFlavour] = ..., by: Optional[Enum] = ...): ...
 
     # endregion
     # region group_by
     @abstractmethod
-    def group_by[TRepo, *Ts](self, column: Callable[[T], TRepo]) -> IStatements[T]: ...
+    def group_by[TRepo](self, column: Callable[[T, *Ts], TRepo]) -> IStatements[T, *Ts]: ...
 
     # endregion
 
@@ -271,7 +317,16 @@ class IStatements[T: Table](ABC):
     def _build(self) -> str: ...
 
 
-class IStatements_two_generic[T: Table, TRepo](IStatements[T]):
+class IStatements_two_generic[T: Table, *Ts, TRepo](IStatements[T, *Ts]):
     @property
     @abstractmethod
     def repository(self) -> IRepositoryBase[TRepo]: ...
+
+    @property
+    def query(self) -> str: ...
+
+    @property
+    def model(self) -> Type[T]: ...
+
+    @property
+    def models(self) -> tuple[*Ts]: ...

ormlambda/databases/my_sql/clauses/alias.py

@@ -0,0 +1,31 @@
+import typing as tp
+from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo, DecompositionQueryBase
+from ormlambda import Table
+
+from ormlambda.common.interfaces import ICustomAlias
+
+
+class Alias[T: tp.Type[Table], *Ts](DecompositionQueryBase[T,*Ts], ICustomAlias[T,*Ts]):
+    def __init__(
+        self,
+        table: T,
+        query: tp.Callable[[T, *Ts], tp.Any],
+        *,
+        alias: bool = True,
+        alias_name: str | None = None,
+    ) -> None:
+        super().__init__(
+            table,
+            lambda_query=query,
+            alias=alias,
+            alias_name=alias_name,
+        )
+
+    def alias_children_resolver[Tclause: tp.Type[Table]](self, clause_info: ClauseInfo[Tclause]):
+        return self.alias_name
+
+    @property
+    def query(self) -> str:
+        assert len(self.all_clauses) == 1
+
+        return self.all_clauses[0].query

ormlambda/databases/my_sql/clauses/group_by.py

@@ -5,13 +5,13 @@ from ormlambda.common.interfaces.IAggregate import IAggregate
 from ormlambda import Table
 
 
-class GroupBy[T: tp.Type[Table], TProp](DecompositionQueryBase[T], IAggregate[T]):
+class GroupBy[T: tp.Type[Table], *Ts, TProp](DecompositionQueryBase[T], IAggregate[T]):
     CLAUSE: str = "GROUP BY"
 
     def __init__(
         self,
         table: T,
-        column: tp.Callable[[T], TProp],
+        column: tp.Callable[[T, *Ts], TProp],
         *,
         alias: bool = True,
         alias_name: str | None = None,

ormlambda/databases/my_sql/clauses/joins.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
-from typing import override, Callable, overload, Optional, TYPE_CHECKING
+from collections import defaultdict
+from typing import override, Callable, overload, Optional, TYPE_CHECKING, Type
 
 
+from ormlambda.utils.module_tree.dfs_traversal import DFSTraversal
 from ormlambda.common.interfaces.IQueryCommand import IQuery
 from ormlambda import Disassembler
 from ormlambda import JoinType
@@ -21,6 +23,13 @@ class JoinSelector[TLeft, TRight](IQuery):
         "_compareop",
     )
 
+    @override
+    def __repr__(self) -> str:
+        table_col_left: str = f"{self._orig_table.__table_name__}.{self._left_col}"
+        table_col_right: str = f"{self._table_right.__table_name__}.{self._right_col}"
+
+        return f"{IQuery.__name__}: {self.__class__.__name__} ({table_col_left} == {table_col_right})"
+
     @overload
     def __init__(
         self,
@@ -102,3 +111,32 @@ class JoinSelector[TLeft, TRight](IQuery):
             right_col,  # second_col
         ]
         return " ".join(list_)
+
+    @classmethod
+    def sort_join_selectors(cls, joins: set[JoinSelector]) -> tuple[JoinSelector]:
+        # FIXME [x]: How to sort when needed because it's not necessary at this point. It is for testing purpouse
+        if len(joins) == 1:
+            return tuple(joins)
+
+        join_object_map: dict[str, list[JoinSelector]] = defaultdict(list)
+
+        for obj in joins:
+            join_object_map[obj._orig_table].append(obj)
+
+        graph: dict[Type[Table], list[Type[Table]]] = defaultdict(list)
+        for join in joins:
+            graph[join._orig_table].append(join._table_right)
+
+        sorted_graph = DFSTraversal.sort(graph)[::-1]
+
+        if not sorted_graph:
+            return tuple(joins)
+
+        res = []
+        for table in sorted_graph:
+            tables = join_object_map[table]
+
+            if not tables:
+                continue
+            res.extend(tables)
+        return res

ormlambda/databases/my_sql/clauses/select.py

@@ -1,32 +1,37 @@
-from typing import override, Type, Callable, TYPE_CHECKING
+from __future__ import annotations
+from typing import override, Type, Callable, TYPE_CHECKING, Optional
 
 from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
 from ormlambda.common.enums.join_type import JoinType
 from ormlambda.common.interfaces.IAggregate import IAggregate
 import shapely as shp
 
+
 if TYPE_CHECKING:
     from ormlambda import Table
+    from .joins import JoinSelector
 
 
-class Select[T: Type[Table]](DecompositionQueryBase[T]):
+class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts]):
     CLAUSE: str = "SELECT"
 
     def __init__(
         self,
-        table: T,
+        tables: tuple[T, *Ts],
         lambda_query: Callable[[T], tuple] = lambda x: x,
         *,
         alias: bool = False,
         alias_name: str | None = None,
+        joins: Optional[list[JoinSelector]] = None,
         by: JoinType = JoinType.INNER_JOIN,
     ) -> None:
         super().__init__(
-            table,
+            tables,
             lambda_query,
             alias=alias,
             alias_name=alias_name,
             by=by,
+            joins=joins,
         )
 
     # @classmethod
@@ -40,18 +45,16 @@ class Select[T: Type[Table]](DecompositionQueryBase[T]):
         cols: list[str] = []
         for x in self.all_clauses:
             if x.dtype is shp.Point:
-                cols.append(x.concat_with_alias(f"ST_AsText({self._table.__table_name__}.{x.column})"))
+                cols.append(x.concat_with_alias(f"ST_AsText({self.table.__table_name__}.{x.column})"))
             else:
                 cols.append(x.query)
 
             if isinstance(x._row_column, IAggregate) and x._row_column.has_foreign_keys:
-                self._fk_relationship.update(x._row_column.fk_relationship)
+                self._joins.update(x._row_column.fk_relationship)
 
         col: str = ", ".join(cols)
-        query: str = f"{self.CLAUSE} {col} FROM {self._table.__table_name__}"
-        alias = ""
+        query: str = f"{self.CLAUSE} {col} FROM {self.table.__table_name__}"
 
-        query += alias
         if self.has_foreign_keys:
             query += " " + self.stringify_foreign_key(" ")
 

ormlambda/databases/my_sql/repository.py

@@ -22,13 +22,14 @@ if TYPE_CHECKING:
     from ormlambda import Table
     from src.ormlambda.databases.my_sql.clauses.select import Select
 
+type TResponse[TFlavour, *Ts] = TFlavour | tuple[dict[str, tuple[*Ts]]] | tuple[tuple[*Ts]] | tuple[TFlavour]
+
 
 class Response[TFlavour, *Ts]:
-    def __init__(self, response_values: list[tuple[*Ts]], columns: tuple[str], flavour: Type[TFlavour], model: Optional[Table] = None, select: Optional[Select] = None, **kwargs) -> None:
+    def __init__(self, response_values: list[tuple[*Ts]], columns: tuple[str], flavour: Type[TFlavour], model: Optional[Table] = None, select: Optional[Select] = None) -> None:
         self._response_values: list[tuple[*Ts]] = response_values
         self._columns: tuple[str] = columns
         self._flavour: Type[TFlavour] = flavour
-        self._kwargs: dict[str, Any] = kwargs
         self._model: Table = model
         self._select: Select = select
 
@@ -47,23 +48,28 @@ class Response[TFlavour, *Ts]:
     def is_many(self) -> bool:
         return self._response_values_index > 1
 
-    @property
-    def response(self) -> tuple[dict[str, tuple[*Ts]]] | tuple[tuple[*Ts]] | tuple[TFlavour]:
+    def response(self, _tuple: bool, **kwargs) -> TResponse[TFlavour, *Ts]:
         if not self.is_there_response:
             return tuple([])
-        clean_response = self._response_values
+        cleaned_response = self._response_values
+
         if self._select is not None:
-            clean_response = self._parser_response()
-        return tuple(self._cast_to_flavour(clean_response))
+            cleaned_response = self._parser_response()
+
+        cast_flavour = self._cast_to_flavour(cleaned_response, **kwargs)
+        if _tuple is not True:
+            return cast_flavour
 
-    def _cast_to_flavour(self, data: list[tuple[*Ts]]) -> list[dict[str, tuple[*Ts]]] | list[tuple[*Ts]] | list[TFlavour]:
-        def _dict() -> list[dict[str, tuple[*Ts]]]:
+        return tuple(cast_flavour)
+
+    def _cast_to_flavour(self, data: list[tuple[*Ts]], **kwargs) -> list[dict[str, tuple[*Ts]]] | list[tuple[*Ts]] | list[TFlavour]:
+        def _dict(**kwargs) -> list[dict[str, tuple[*Ts]]]:
             return [dict(zip(self._columns, x)) for x in data]
 
-        def _tuple() -> list[tuple[*Ts]]:
+        def _tuple(**kwargs) -> list[tuple[*Ts]]:
             return data
 
-        def _set() -> list[set]:
+        def _set(**kwargs) -> list[set]:
             for d in data:
                 n = len(d)
                 for i in range(n):
@@ -73,16 +79,20 @@ class Response[TFlavour, *Ts]:
                         raise TypeError(f"unhashable type '{type(d[i])}' found in '{type(d)}' when attempting to cast the result into a '{set.__name__}' object")
             return [set(x) for x in data]
 
-        def _default() -> list[TFlavour]:
-            return [self._flavour(x, **self._kwargs) for x in data]
+        def _list(**kwargs) -> list[list]:
+            return [list(x) for x in data]
+
+        def _default(**kwargs) -> list[TFlavour]:
+            return self._flavour(data, **kwargs)
 
         selector: dict[Type[object], Any] = {
             dict: _dict,
             tuple: _tuple,
             set: _set,
+            list: _list,
         }
 
-        return selector.get(self._flavour, _default)()
+        return selector.get(self._flavour, _default)(**kwargs)
 
     def _parser_response(self) -> TFlavour:
         new_response: list[list] = []
@@ -123,8 +133,7 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         def wrapper(self: MySQLRepository, *args, **kwargs):
             with self._pool.get_connection() as cnx:
                 try:
-                    foo = func(self, cnx._cnx, *args, **kwargs)
-                    return foo
+                    return func(self, cnx._cnx, *args, **kwargs)
                 except Exception as e:
                     cnx._cnx.rollback()
                     raise e
@@ -140,7 +149,13 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
 
     @override
     @get_connection
-    def read_sql[TFlavour](self, cnx: MySQLConnection, query: str, flavour: Type[TFlavour] = tuple, **kwargs) -> tuple[TFlavour]:
+    def read_sql[TFlavour](
+        self,
+        cnx: MySQLConnection,
+        query: str,
+        flavour: Type[TFlavour] = tuple,
+        **kwargs,
+    ) -> tuple[TFlavour]:
         """
         Return tuple of tuples by default.
 
@@ -150,19 +165,15 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
             - flavour: Type[TFlavour]: Useful to return tuple of any Iterable type as dict,set,list...
         """
 
-        def get_and_drop_key(key: str) -> Optional[Any]:
-            if key in kwargs:
-                return kwargs.pop(key)
-            return None
-
-        model: Table = get_and_drop_key("model")
-        select: Select = get_and_drop_key("select")
+        model: Table = kwargs.pop("model", None)
+        select: Select = kwargs.pop("select", None)
+        cast_to_tuple: bool = kwargs.pop("cast_to_tuple", True)
 
         with cnx.cursor(buffered=True) as cursor:
             cursor.execute(query)
             values: list[tuple] = cursor.fetchall()
             columns: tuple[str] = cursor.column_names
-            return Response[TFlavour](model=model, response_values=values, columns=columns, flavour=flavour, select=select, **kwargs).response
+            return Response[TFlavour](model=model, response_values=values, columns=columns, flavour=flavour, select=select).response(_tuple=cast_to_tuple, **kwargs)
 
     # FIXME [ ]: this method does not comply with the implemented interface
     @get_connection