ormlambda 2.11.1__py3-none-any.whl → 3.7.0__py3-none-any.whl

ormlambda/databases/my_sql/clauses/count.py

@@ -1,39 +1,43 @@
+from __future__ import annotations
+from ormlambda.sql.clause_info import AggregateFunctionBase
+from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+
+from ormlambda.sql.types import AliasType, ColumnType
+
+from ormlambda import Table
+
 import typing as tp
 
+from ormlambda.sql.types import ASTERISK
+
 if tp.TYPE_CHECKING:
     from ormlambda import Table
-from ormlambda.common.interfaces import IAggregate
-from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase, ClauseInfo
-from ormlambda import JoinType
+    from ormlambda.sql.types import ColumnType, AliasType, TableType
 
 
-class Count[T: tp.Type[Table]](DecompositionQueryBase[T], IAggregate[T]):
-    NAME: str = "COUNT"
+class Count[T: Table](AggregateFunctionBase[T]):
+    @staticmethod
+    def FUNCTION_NAME() -> str:
+        return "COUNT"
 
-    def __init__(
+    def __init__[TProp: Table](
         self,
-        table: T,
-        lambda_query: str | tp.Callable[[T], tuple],
-        *,
-        alias: bool = True,
-        alias_name: str = "count",
-        by: JoinType = JoinType.INNER_JOIN,
+        element: ColumnType[T] | TableType[TProp],
+        alias_table: AliasType[ColumnType[TProp]] = None,
+        alias_clause: AliasType[ColumnType[TProp]] = "count",
+        context: ClauseContextType = None,
+        keep_asterisk: bool = True,
+        preserve_context: bool = True,
     ) -> None:
+        table = self.extract_table(element)
+        column = element if self.is_column(element) else ASTERISK
+
         super().__init__(
-            table,
-            lambda_query=lambda_query,
-            alias=alias,
-            alias_name=alias_name,
-            by=by,
-            replace_asterisk_char=False,
+            table=table if (alias_table or (context and table in context._table_context)) else None,
+            column=column,
+            alias_table=alias_table,
+            alias_clause=alias_clause,
+            context=context,
+            keep_asterisk=keep_asterisk,
+            preserve_context=preserve_context,
         )
-
-    def alias_children_resolver[Tclause: tp.Type[Table]](self, clause_info: ClauseInfo[Tclause]):
-        if isinstance(clause_info._row_column, IAggregate):
-            return clause_info._row_column.alias
-        return None
-
-    @property
-    def query(self) -> str:
-        col = ", ".join([x.query for x in self.all_clauses])
-        return f"{self.NAME}({col})"

ormlambda/databases/my_sql/clauses/create_database.py

@@ -1,15 +1,14 @@
 from typing import Literal, override
 from mysql.connector import errorcode, errors
-from mysql.connector import MySQLConnection
 
-from ormlambda import IRepositoryBase
+from ormlambda.repository import BaseRepository
 
 TypeExists = Literal["fail", "replace", "append"]
 
 
 class CreateDatabase:
-    def __init__(self, repository: IRepositoryBase[MySQLConnection]) -> None:
-        self._repository: IRepositoryBase[MySQLConnection] = repository
+    def __init__(self, repository: BaseRepository) -> None:
+        self._repository: BaseRepository = repository
 
     @override
     @property

ormlambda/databases/my_sql/clauses/delete.py

@@ -1,16 +1,16 @@
-from typing import Any, override, Iterable, TYPE_CHECKING
+from typing import Any, Optional, override, Iterable, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ormlambda import Column
 
 from ormlambda import Table
-from ormlambda import IRepositoryBase
+from ormlambda.repository import IRepositoryBase
 from ormlambda.components.delete import DeleteQueryBase
 from mysql.connector import MySQLConnection
 
 
-class DeleteQuery[T: Table](DeleteQueryBase[T, IRepositoryBase[MySQLConnection]]):
-    def __init__(self, model: T, repository: IRepositoryBase[MySQLConnection]) -> None:
+class DeleteQuery[T: Table](DeleteQueryBase[T, IRepositoryBase]):
+    def __init__(self, model: T, repository: IRepositoryBase) -> None:
         super().__init__(model, repository)
 
     @property
@@ -21,18 +21,18 @@ class DeleteQuery[T: Table](DeleteQueryBase[T, IRepositoryBase[MySQLConnection]]
     def delete(self, instances: T | list[T]) -> None:
         col: str = ""
         if isinstance(instances, Table):
-            pk: Column = instances.get_pk()
-            if pk.column_value is None:
+            pk: Optional[Column] = instances.get_pk()
+            if pk is None:
                 raise Exception(f"You cannot use 'DELETE' query without set primary key in '{instances.__table_name__}'")
             col = pk.column_name
-            value = str(pk.column_value)
+            value = str(instances[pk])
 
         elif isinstance(instances, Iterable):
             value: list[Any] = []
             for ins in instances:
-                pk = ins.get_pk()
-                col = pk.column_name
-                value.append(pk.column_value)
+                pk = type(ins).get_pk()
+                value.append(ins[pk])
+            col = pk.column_name
 
         query: str = f"{self.CLAUSE} FROM {self._model.__table_name__} WHERE {col}"
         if isinstance(value, str):

ormlambda/databases/my_sql/clauses/drop_database.py

@@ -1,13 +1,11 @@
 from typing import override
-from mysql.connector import MySQLConnection
 
-
-from ormlambda import IRepositoryBase
+from ormlambda.repository import IRepositoryBase
 
 
 class DropDatabase:
-    def __init__(self, repository: IRepositoryBase[MySQLConnection]) -> None:
-        self._repository: IRepositoryBase[MySQLConnection] = repository
+    def __init__(self, repository: IRepositoryBase) -> None:
+        self._repository: IRepositoryBase = repository
 
     @override
     def execute(self, name: str) -> None:

ormlambda/databases/my_sql/clauses/drop_table.py

@@ -1,6 +1,6 @@
 from typing import Literal, override
 
-from ormlambda import IRepositoryBase
+from ormlambda.repository import IRepositoryBase
 
 from mysql.connector import MySQLConnection
 
@@ -8,8 +8,8 @@ TypeExists = Literal["fail", "replace", "append"]
 
 
 class DropTable:
-    def __init__(self, repository: IRepositoryBase[MySQLConnection]) -> None:
-        self._repository: IRepositoryBase[MySQLConnection] = repository
+    def __init__(self, repository: IRepositoryBase) -> None:
+        self._repository: IRepositoryBase = repository
 
     @override
     def execute(self, name: str = None) -> None:

ormlambda/databases/my_sql/clauses/group_by.py

@@ -1,11 +1,11 @@
 import typing as tp
 from ormlambda.common.enums.join_type import JoinType
-from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo, DecompositionQueryBase
-from ormlambda.common.interfaces.IAggregate import IAggregate
+from ormlambda.sql.clause_info import IAggregate
 from ormlambda import Table
+from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
 
 
-class GroupBy[T: tp.Type[Table], *Ts, TProp](DecompositionQueryBase[T], IAggregate[T]):
+class GroupBy[T: tp.Type[Table], *Ts, TProp](DecompositionQueryBase[T], IAggregate):
     CLAUSE: str = "GROUP BY"
 
     def __init__(
@@ -19,15 +19,12 @@ class GroupBy[T: tp.Type[Table], *Ts, TProp](DecompositionQueryBase[T], IAggrega
     ) -> None:
         super().__init__(
             table,
-            lambda_query=column,
+            columns=column,
             alias=alias,
             alias_name=alias_name,
             by=by,
         )
 
-    def alias_children_resolver[Tclause: tp.Type[Table]](self, clause_info: ClauseInfo[Tclause]):
-        return None
-
     @property
     def query(self) -> str:
         col: str = ", ".join([x.query for x in self.all_clauses])

ormlambda/databases/my_sql/clauses/insert.py

@@ -1,14 +1,19 @@
-from typing import override, Iterable
-from mysql.connector import MySQLConnection
+from __future__ import annotations
+
+from typing import override, Iterable, TYPE_CHECKING
 
 from ormlambda import Table
 from ormlambda import Column
 from ormlambda.components.insert import InsertQueryBase
-from ormlambda import IRepositoryBase
+from ormlambda.repository import IRepositoryBase
+from ormlambda.caster import Caster
+
+if TYPE_CHECKING:
+    from ormlambda.databases.my_sql import MySQLRepository
 
 
-class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase[MySQLConnection]]):
-    def __init__(self, model: T, repository: IRepositoryBase[IRepositoryBase[MySQLConnection]]) -> None:
+class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase]):
+    def __init__(self, model: T, repository: MySQLRepository) -> None:
         super().__init__(model, repository)
 
     @override
@@ -23,8 +28,10 @@ class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase[MySQLConnection]]
         return self._repository.executemany_with_values(self.query, self._values)
 
     @override
-    def insert(self, instances: T | list[T]) -> None:
-        valid_cols: list[list[Column]] = []
+    def insert[TProp](self, instances: T | list[T]) -> None:
+        if not isinstance(instances, Iterable):
+            instances = (instances,)
+        valid_cols: list[list[Column[TProp]]] = []
         self.__fill_dict_list(valid_cols, instances)
 
         col_names: list[str] = []
@@ -32,11 +39,14 @@ class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase[MySQLConnection]]
         col_values: list[list[str]] = []
         for i, cols in enumerate(valid_cols):
             col_values.append([])
+            CASTER = Caster(self._repository)
             for col in cols:
+                clean_data = CASTER.for_column(col, instances[i])  # .resolve(instances[i][col])
                 if i == 0:
                     col_names.append(col.column_name)
-                    wildcards.append(col.placeholder)
-                col_values[-1].append(col.column_value_to_query)
+                    wildcards.append(clean_data.wildcard_to_insert())
+                # COMMENT: avoid MySQLWriteCastBase.resolve when using PLACEHOLDERs
+                col_values[-1].append(clean_data.to_database)
 
         join_cols = ", ".join(col_names)
         unknown_rows = f'({", ".join(wildcards)})'  # The number of "%s" must match the dict 'dicc_0' length
@@ -46,7 +56,7 @@ class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase[MySQLConnection]]
         return None
 
     @staticmethod
-    def __is_valid(column: Column) -> bool:
+    def __is_valid[TProp](column: Column[TProp], value: TProp) -> bool:
         """
         We want to delete the column from table when it's specified with an 'AUTO_INCREMENT' or 'AUTO GENERATED ALWAYS AS (__) STORED' statement.
 
@@ -60,24 +70,28 @@ class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase[MySQLConnection]]
         - False -> Delete the column from dict query
         """
 
-        is_pk_none_and_auto_increment: bool = all([column.column_value is None, column.is_primary_key, column.is_auto_increment])
+        is_pk_none_and_auto_increment: bool = all([value is None, column.is_primary_key, column.is_auto_increment])
 
         if is_pk_none_and_auto_increment or column.is_auto_generated:
             return False
         return True
 
-    def __fill_dict_list[TProp](self, list_dict: list[str, TProp], values: T | list[T]) -> list[Column]:
-        if issubclass(values.__class__, Table):
+    def __fill_dict_list[TProp](self, list_dict: list[str, TProp], values: list[T]) -> list[Column]:
+        if isinstance(values, Iterable):
+            for x in values:
+                self.__fill_dict_list(list_dict, x)
+
+        elif issubclass(values.__class__, Table):
             new_list = []
-            for col in values.__dict__.values():
-                if isinstance(col, Column) and self.__is_valid(col):
-                    new_list.append(col)
+            for prop in type(values).__dict__.values():
+                if not isinstance(prop, Column):
+                    continue
 
+                value = getattr(values, prop.column_name)
+                if self.__is_valid(prop, value):
+                    new_list.append(prop)
             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,88 +1,71 @@
 from __future__ import annotations
 from collections import defaultdict
-from typing import override, Callable, overload, Optional, TYPE_CHECKING, Type
+from typing import override, Optional, TYPE_CHECKING, Type
 
 
 from ormlambda.utils.module_tree.dfs_traversal import DFSTraversal
+from ormlambda.common.interfaces.IJoinSelector import IJoinSelector
 from ormlambda.common.interfaces.IQueryCommand import IQuery
-from ormlambda import Disassembler
 from ormlambda import JoinType
+from ormlambda.sql.clause_info import ClauseInfo
+from ormlambda.sql.comparer import Comparer
+from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
 
 # TODOL [x]: Try to import Table module without circular import Error
 if TYPE_CHECKING:
     from ormlambda import Table
 
 
-class JoinSelector[TLeft, TRight](IQuery):
+class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight]):
     __slots__: tuple = (
+        "_comparer",
         "_orig_table",
-        "_table_right",
+        "_right_table",
         "_by",
         "_left_col",
         "_right_col",
         "_compareop",
+        "_alias",
     )
 
     @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}"
+        table_col_left: str = f"{self.left_table.table_alias()}.{self._left_col}"
+        table_col_right: str = f"{self.right_table.table_alias()}.{self._right_col}"
 
         return f"{IQuery.__name__}: {self.__class__.__name__} ({table_col_left} == {table_col_right})"
 
-    @overload
-    def __init__(
+    def __init__[LProp, RProp](
         self,
-        table_left: TLeft,
-        table_right: TRight,
-        col_left: str,
-        col_right: str,
+        where: Comparer[TLeft, LProp, TRight, RProp],
         by: JoinType,
-    ) -> None: ...
-
-    @overload
-    def __init__(
-        self,
-        table_left: TLeft,
-        table_right: TRight,
-        by: JoinType,
-        where: Callable[[TLeft, TRight], bool],
-    ) -> None: ...
-
-    def __init__(
-        self,
-        table_left: Table,
-        table_right: Table,
-        by: JoinType,
-        col_left: Optional[str] = None,
-        col_right: Optional[str] = None,
-        where: Optional[Callable[[TLeft, TRight], bool]] = None,
+        alias: Optional[str] = "{table}",
+        context: ClauseContextType = None,
     ) -> None:
-        self._orig_table: Table = table_left
-        self._table_right: Table = table_right
+        self._comparer: Comparer[TLeft, LProp, TRight, RProp] = where
+        self._orig_table: TLeft = where.left_condition.table
+        self._right_table: TRight = where.right_condition.table
         self._by: JoinType = by
+        self._left_col: str = where.left_condition._column.column_name
+        self._right_col: str = where.right_condition._column.column_name
+        self._compareop = where._compare
+        self._context: ClauseContextType = context if context else ClauseInfoContext()
 
-        if all(x is None for x in (col_left, col_right, where)):
-            raise ValueError("You must specify at least 'where' clausule or ('_left_col',_right_col')")
+        # COMMENT: When multiple columns reference the same table, we need to create an alias to maintain clear references.
+        self._alias: Optional[str] = alias
 
-        if where is None:
-            self._left_col: str = col_left
-            self._right_col: str = col_right
-            self._compareop: str = "="
-        else:
-            _dis: Disassembler[TLeft, TRight] = Disassembler[TLeft, TRight](where)
-            self._left_col: str = _dis.cond_1.name
-            self._right_col: str = _dis.cond_2.name
-            self._compareop: str = _dis.compare_op
+        self._from_clause = ClauseInfo(self.right_table, alias_table=alias, context=self._context)
+        self._left_table_clause = ClauseInfo(self.left_table, column=self.left_col, alias_clause=None, context=self._create_partial_context())
+        self._right_table_clause = ClauseInfo(self.right_table, column=self.right_col, alias_clause=None, context=self._create_partial_context())
 
-    def __eq__(self, __value: "JoinSelector") -> bool:
+    def __eq__(self, __value: JoinSelector) -> bool:
         return isinstance(__value, JoinSelector) and self.__hash__() == __value.__hash__()
 
     def __hash__(self) -> int:
         return hash(
             (
-                self._orig_table,
-                self._table_right,
+                self.left_table,
+                self.right_table,
                 self._by,
                 self._left_col,
                 self._right_col,
@@ -90,27 +73,51 @@ class JoinSelector[TLeft, TRight](IQuery):
             )
         )
 
+    def _create_partial_context(self) -> ClauseInfoContext:
+        """
+        Only use table_context from global context
+        """
+        if not self._context:
+            return ClauseInfoContext()
+        return ClauseInfoContext(clause_context=None, table_context=self._context._table_context)
+
     @classmethod
-    def join_selectors(cls, *args: "JoinSelector") -> str:
+    def join_selectors(cls, *args: JoinSelector) -> str:
         return "\n".join([x.query for x in args])
 
     @property
     @override
     def query(self) -> str:
-        # {inner join} table_name on
-        #   table_name.first col = table_name.second_col
-
-        left_col = f"{self._orig_table.__table_name__}.{self._left_col}"
-        right_col = f"{self._table_right.__table_name__}.{self._right_col}"
+        self._context = ClauseInfoContext(clause_context=None, table_context=self._context._table_context)
         list_ = [
             self._by.value,  # inner join
-            self._table_right.__table_name__,  # table_name
+            self._from_clause.query,
             "ON",
-            left_col,  # first_col
+            self._left_table_clause.query,
             self._compareop,  # =
-            right_col,  # second_col
+            self._right_table_clause.query,
         ]
-        return " ".join(list_)
+        return " ".join([x for x in list_ if x is not None])
+
+    @property
+    def left_table(self) -> TLeft:
+        return self._orig_table
+
+    @property
+    def right_table(self) -> TRight:
+        return self._right_table
+
+    @property
+    def left_col(self) -> str:
+        return self._left_col
+
+    @property
+    def right_col(self) -> str:
+        return self._right_col
+
+    @property
+    def alias(self) -> str:
+        return self._alias
 
     @classmethod
     def sort_join_selectors(cls, joins: set[JoinSelector]) -> tuple[JoinSelector]:
@@ -121,11 +128,11 @@ class JoinSelector[TLeft, TRight](IQuery):
         join_object_map: dict[str, list[JoinSelector]] = defaultdict(list)
 
         for obj in joins:
-            join_object_map[obj._orig_table].append(obj)
+            join_object_map[obj.left_table].append(obj)
 
         graph: dict[Type[Table], list[Type[Table]]] = defaultdict(list)
         for join in joins:
-            graph[join._orig_table].append(join._table_right)
+            graph[join.left_table].append(join.right_table)
 
         sorted_graph = DFSTraversal.sort(graph)[::-1]
 

ormlambda/databases/my_sql/clauses/limit.py

@@ -3,7 +3,7 @@ from typing import override
 from ormlambda.common.interfaces.IQueryCommand import IQuery
 
 
-class LimitQuery(IQuery):
+class Limit(IQuery):
     LIMIT = "LIMIT"
 
     def __init__(self, number: int) -> None:

ormlambda/databases/my_sql/clauses/offset.py

@@ -3,7 +3,7 @@ from typing import override
 from ormlambda.common.interfaces.IQueryCommand import IQuery
 
 
-class OffsetQuery(IQuery):
+class Offset(IQuery):
     OFFSET = "OFFSET"
 
     def __init__(self, number: int) -> None:

ormlambda/databases/my_sql/clauses/order.py

@@ -1,28 +1,36 @@
 from __future__ import annotations
-from typing import override, Callable, TYPE_CHECKING, Any, Iterable
+import typing as tp
 
-from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
+from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
+from ormlambda.sql.types import ColumnType
+from ormlambda.sql.clause_info import AggregateFunctionBase
 
+from ormlambda.statements import OrderType
 
-if TYPE_CHECKING:
-    from ormlambda import Table
 
-from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
-from ormlambda.common.interfaces.IStatements import OrderType
+class Order(AggregateFunctionBase):
+    @staticmethod
+    def FUNCTION_NAME() -> str:
+        return "ORDER BY"
 
+    def __init__[TProp](
+        self,
+        column: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
+        order_type: tp.Iterable[OrderType],
+        context: ClauseContextType = None,
+    ):
+        super().__init__(
+            table=None,
+            column=column,
+            context=context,
+        )
 
-class OrderQuery[T: Table](DecompositionQueryBase[T]):
-    ORDER = "ORDER BY"
-
-    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):
+        if isinstance(order_type, str) or not isinstance(order_type, tp.Iterable):
             order_type = (order_type,)
 
         self._order_type: list[OrderType] = [self.__cast_to_OrderType(x) for x in order_type]
 
-    def __cast_to_OrderType(self, _value: Any) -> Iterable[OrderType]:
+    def __cast_to_OrderType(self, _value: tp.Any) -> tp.Iterable[OrderType]:
         if isinstance(_value, OrderType):
             return _value
 
@@ -33,15 +41,20 @@ class OrderQuery[T: Table](DecompositionQueryBase[T]):
                 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
+    @tp.override
     @property
     def query(self) -> str:
-        assert len(self.all_clauses) == len(self._order_type)
+        string_columns: list[str] = []
+        columns = self.unresolved_column
+
+        # if this attr is not iterable means that we only pass one column without wrapped in a list or tuple
+        if not isinstance(columns, tp.Iterable):
+            columns = (columns,)
+        assert len(columns) == len(self._order_type)
+
+        context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
+        for index, clause in enumerate(self._convert_into_clauseInfo(columns, context)):
+            clause.alias_clause = None
+            string_columns.append(f"{clause.query} {self._order_type[index].value}")
 
-        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)}"
+        return f"{self.FUNCTION_NAME()} {', '.join(string_columns)}"