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

ormlambda/common/interfaces/IStatements.py

@@ -1,7 +1,8 @@
 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
 
 from .IRepositoryBase import IRepositoryBase
 from ormlambda.common.enums import JoinType
@@ -10,19 +11,54 @@ if TYPE_CHECKING:
     from ormlambda import Table
     from .IAggregate import IAggregate
 
-OrderType = Literal["ASC", "DESC"]
+
+class OrderType(enum.Enum):
+    ASC = "ASC"
+    DESC = "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]]
+
 
 # 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: ...
 
@@ -109,18 +145,13 @@ class IStatements[T: Table](ABC):
     @overload
     def delete(self, instance: list[T]) -> None: ...
     @abstractmethod
-    def delete(self, instance: Optional[T | list[T]] = None) -> None: ...
+    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
@@ -131,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
         -
@@ -148,16 +179,16 @@ 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
     @overload
     def order[TValue](self, _lambda_col: Callable[[T], TValue]) -> IStatements[T]: ...
     @overload
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements[T]: ...
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderTypes) -> IStatements[T]: ...
     @abstractmethod
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements[T]: ...
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderTypes) -> IStatements[T]: ...
 
     # endregion
     # region concat
@@ -191,72 +222,94 @@ 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] = JoinType.INNER_JOIN) -> 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] = JoinType.INNER_JOIN) -> 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] = JoinType.INNER_JOIN) -> 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] = JoinType.INNER_JOIN) -> 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] = JoinType.INNER_JOIN) -> 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] = JoinType.INNER_JOIN) -> 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] = JoinType.INNER_JOIN) -> 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] = JoinType.INNER_JOIN) -> 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] = JoinType.INNER_JOIN) -> 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] = JoinType.INNER_JOIN
-    ) -> 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] = JoinType.INNER_JOIN
-    ) -> 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[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], Ts]] = None, *, flavour: Type[tuple], by: Optional[Enum] = JoinType.INNER_JOIN) -> 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]]] = None, *, flavour: Type[tuple], by: Optional[Enum] = JoinType.INNER_JOIN) -> 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[*Ts](self, selector: Optional[Callable[[T], tuple[*Ts]]] = None, *, flavour: Type[tuple], by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[tuple[*Ts]]: ...
+    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], tuple]] = None, *, flavour: Type[TFlavour], by: Optional[Enum] = JoinType.INNER_JOIN) -> tuple[TFlavour]: ...
+    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]]] = lambda: None, *, flavour: Type[TFlavour] = None, by: JoinType = JoinType.INNER_JOIN): ...
+    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
     @overload
     def select_one(self) -> T: ...
     @overload
-    def select_one[TFlavour](self, *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[TFlavour]) -> TFlavour: ...
+    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] = JoinType.INNER_JOIN) -> 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] = JoinType.INNER_JOIN) -> 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] = JoinType.INNER_JOIN, 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] = JoinType.INNER_JOIN, 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] = JoinType.INNER_JOIN, 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] = JoinType.INNER_JOIN, 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] = None, by: Optional[Enum] = JoinType.INNER_JOIN): ...
+    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
 
@@ -264,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/insert.py

@@ -1,4 +1,4 @@
-from typing import Any, override, Iterable
+from typing import override, Iterable
 from mysql.connector import MySQLConnection
 
 from ormlambda import Table
@@ -24,13 +24,24 @@ class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase[MySQLConnection]]
 
     @override
     def insert(self, instances: T | list[T]) -> None:
-        new_dict_list: list[dict[str, Any]] = []
-        self.__fill_dict_list(new_dict_list, instances)
-        cols_tuple = new_dict_list[0].keys()
-        join_cols = ", ".join(cols_tuple)
-        unknown_rows = f'({", ".join(["%s"]*len(cols_tuple))})'  # The number of "%s" must match the dict 'dicc_0' length
+        valid_cols: list[list[Column]] = []
+        self.__fill_dict_list(valid_cols, instances)
 
-        self._values = [tuple(x.values()) for x in new_dict_list]
+        col_names: list[str] = []
+        wildcards: list[str] = []
+        col_values: list[list[str]] = []
+        for i, cols in enumerate(valid_cols):
+            col_values.append([])
+            for col in cols:
+                if i == 0:
+                    col_names.append(col.column_name)
+                    wildcards.append(col.placeholder)
+                col_values[-1].append(col.column_value_to_query)
+
+        join_cols = ", ".join(col_names)
+        unknown_rows = f'({", ".join(wildcards)})'  # The number of "%s" must match the dict 'dicc_0' length
+
+        self._values = [tuple(x) for x in col_values]
         self._query = f"{self.CLAUSE} {self._model.__table_name__} {f'({join_cols})'} VALUES {unknown_rows}"
         return None
 
@@ -55,17 +66,18 @@ class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase[MySQLConnection]]
             return False
         return True
 
-    def __fill_dict_list(self, list_dict: list[dict], values: T | list[T]):
+    def __fill_dict_list[TProp](self, list_dict: list[str, TProp], values: T | list[T]) -> list[Column]:
         if issubclass(values.__class__, Table):
-            dicc: dict = {}
+            new_list = []
             for col in values.__dict__.values():
                 if isinstance(col, Column) and self.__is_valid(col):
-                    dicc.update({col.column_name: col.column_value})
-            list_dict.append(dicc)
-            return list_dict
+                    new_list.append(col)
+
+            list_dict.append(new_list)
 
         elif isinstance(values, Iterable):
             for x in values:
                 self.__fill_dict_list(list_dict, x)
         else:
             raise Exception(f"Tipo de dato'{type(values)}' no esperado")
+        return 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/order.py

@@ -1,33 +1,47 @@
 from __future__ import annotations
-from typing import override, Callable, TYPE_CHECKING
+from typing import override, Callable, TYPE_CHECKING, Any, Iterable
+
+from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
+
 
 if TYPE_CHECKING:
     from ormlambda import Table
 
-from ormlambda.utils.lambda_disassembler.tree_instruction import TreeInstruction
-from ormlambda.common.interfaces.IQueryCommand import IQuery
+from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
 from ormlambda.common.interfaces.IStatements import OrderType
 
-ASC = "ASC"
-DESC = "DESC"
 
-
-class OrderQuery[T:Table](IQuery):
+class OrderQuery[T: Table](DecompositionQueryBase[T]):
     ORDER = "ORDER BY"
 
-    def __init__(self, instance: T, order_lambda: Callable[[T], None], order_type: OrderType) -> None:
-        if not self._valid_order_type(order_type):
-            raise Exception("order_type only can be 'ASC' or 'DESC'")
+    def __init__[*Ts](self, instance: T, lambda_query: Callable[[Any], tuple[*Ts]], order_type: Iterable[OrderType]) -> None:
+        super().__init__(instance, lambda_query)
+
+        if isinstance(order_type, str) or not isinstance(order_type, Iterable):
+            order_type = (order_type,)
 
-        self._instance: T = instance
-        self._order_lambda: Callable[[T], None] = order_lambda
-        self._order_type: str = order_type
-        self._column: str = TreeInstruction(order_lambda).to_list()[0].nested_element.name
+        self._order_type: list[OrderType] = [self.__cast_to_OrderType(x) for x in order_type]
 
-    def _valid_order_type(self, _value: str) -> bool:
-        return _value in (ASC, DESC)
+    def __cast_to_OrderType(self, _value: Any) -> Iterable[OrderType]:
+        if isinstance(_value, OrderType):
+            return _value
+
+        if isinstance(_value, str):
+            try:
+                return OrderType(_value)
+            except Exception:
+                pass
+        raise Exception(f"order_type param only can be 'ASC' or 'DESC' string or '{OrderType.__name__}' enum")
+
+    def alias_children_resolver[Tclause](self, clause_info: ClauseInfo[Tclause]):
+        return None
 
     @override
     @property
     def query(self) -> str:
-        return f"{self.ORDER} {self._instance.__table_name__}.{self._column} {self._order_type}"
+        assert len(self.all_clauses) == len(self._order_type)
+
+        query: list[str] = []
+        for index, x in enumerate(self.all_clauses):
+            query.append(f"{x.query} {self._order_type[index].value}")
+        return f"{self.ORDER} {", ".join(query)}"

ormlambda/databases/my_sql/clauses/select.py

@@ -1,53 +1,60 @@
-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
     # def alias_children_resolver[Tclause: Type[Table]](self, clause_info: ClauseInfo[Tclause]):
     #     return f"{clause.table.__table_name__}_{name}"
 
+    # TODOL: see who to deal when we will have to add more mysql methods
     @override
     @property
     def query(self) -> str:
-        cols:list[str] = []
+        cols: list[str] = []
         for x in self.all_clauses:
-            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)
+            if x.dtype is shp.Point:
+                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._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/clauses/update.py

@@ -27,26 +27,20 @@ class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase[MySQLConnec
         if not isinstance(dicc, dict):
             raise TypeError
 
-        name_cols: list[str] = []
+        name_cols: list[Column] = []
 
         for col, value in dicc.items():
-            if isinstance(col, str):
-                string_col = col
-            else:
-                string_col = self._model.__properties_mapped__.get(col, None)
-                if not string_col:
-                    raise KeyError(f"Class '{self._model.__name__}' has not {col} mapped.")
-            if self.__is_valid__(string_col, value):
-                name_cols.append(string_col)
-                self._values.append(value)
-
-        set_query: str = ",".join(["=".join([col, "%s"]) for col in name_cols])
+            col: Column = self._model.get_column(col, value)
+
+            if self.__is_valid__(col):
+                name_cols.append(col)
+                self._values.append(col.column_value_to_query)
+
+        set_query: str = ",".join(["=".join([col.column_name, col.placeholder]) for col in name_cols])
 
         self._query = f"{self.CLAUSE} {self._model.__table_name__} SET {set_query}"
+        self._values = tuple(self._values)
         return None
 
-    def __is_valid__(self, col: str, value: Any) -> bool:
-        instance_table: Table = self._model(**{col: value})
-
-        column: Column = getattr(instance_table, f"_{col}")
-        return not column.is_auto_generated
+    def __is_valid__(self, col: Column) -> bool:
+        return not col.is_auto_generated