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

ormlambda/databases/my_sql/clauses/select.py

@@ -1,61 +1,50 @@
 from __future__ import annotations
-from typing import override, Type, Callable, TYPE_CHECKING, Optional
+from typing import Optional, override, Type, Callable, TYPE_CHECKING
 
+from ormlambda.sql.clause_info import ClauseInfo
+from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
+from ormlambda.sql.types import AliasType
 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
-
+from ormlambda.components import ISelect
 
 if TYPE_CHECKING:
     from ormlambda import Table
-    from .joins import JoinSelector
 
 
-class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts]):
+class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ISelect):
     CLAUSE: str = "SELECT"
 
     def __init__(
         self,
         tables: tuple[T, *Ts],
-        lambda_query: Callable[[T], tuple] = lambda x: x,
+        columns: Callable[[T], tuple] = lambda x: x,
         *,
-        alias: bool = False,
-        alias_name: str | None = None,
-        joins: Optional[list[JoinSelector]] = None,
-        by: JoinType = JoinType.INNER_JOIN,
+        alias_table: AliasType[ClauseInfo] = "{table}",
+        context: Optional[ClauseInfoContext] = None,
     ) -> None:
         super().__init__(
             tables,
-            lambda_query,
-            alias=alias,
-            alias_name=alias_name,
-            by=by,
-            joins=joins,
+            columns,
+            context=context,
         )
+        self._alias_table = alias_table
+        # We always need to add the self alias of the Select
+        self._context._add_table_alias(self.table, self._alias_table)
+
+    @property
+    def FROM(self) -> ClauseInfo[T]:
+        return ClauseInfo(self.table, None, alias_table=self._alias_table, context=self._context)
 
-    # @classmethod
-    # def alias_children_resolver[Tclause: Type[Table]](self, clause_info: ClauseInfo[Tclause]):
-    #     return f"{clause.table.__table_name__}_{name}"
+    @property
+    def COLUMNS(self) -> str:
+        return ClauseInfo.join_clauses(self._all_clauses, ",", self.context)
 
     # TODOL: see who to deal when we will have to add more mysql methods
     @override
     @property
     def query(self) -> str:
-        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})"))
-            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__}"
-
-        if self.has_foreign_keys:
-            query += " " + self.stringify_foreign_key(" ")
+        # 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'
+        FROM = self.FROM
 
-        return query
+        return f"{self.CLAUSE} {self.COLUMNS} FROM {FROM.query}"

ormlambda/databases/my_sql/clauses/update.py

@@ -1,14 +1,27 @@
 from typing import Type, override, Any
-from mysql.connector import MySQLConnection
 
 from ormlambda.components.update import UpdateQueryBase
 from ormlambda import Table, Column
-from ormlambda import IRepositoryBase
-from .where_condition import WhereCondition
+from ormlambda.repository import IRepositoryBase
+from ormlambda.caster.caster import Caster
+from .where import Where
+from ormlambda.sql.types import ColumnType
 
 
-class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase[MySQLConnection]]):
-    def __init__(self, model: T, repository: Any, where: list[WhereCondition]) -> None:
+class UpdateKeyError(KeyError):
+    def __init__(self, table: Type[Table], key: str | ColumnType, *args):
+        super().__init__(*args)
+        self._table: Type[Table] = table
+        self._key: str | ColumnType = key
+
+    def __str__(self):
+        if isinstance(self._key, Column):
+            return f"The column '{self._key.column_name}' does not belong to the table '{self._table.__table_name__}'; it belongs to the table '{self._key.table.__table_name__}'. Please check the columns in the query."
+        return f"The column '{self._key}' does not belong to the table '{self._table.__table_name__}'. Please check the columns in the query."
+
+
+class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase]):
+    def __init__(self, model: T, repository: Any, where: list[Where]) -> None:
         super().__init__(model, repository, where)
 
     @override
@@ -19,28 +32,40 @@ class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase[MySQLConnec
     @override
     def execute(self) -> None:
         if self._where:
-            self._query += " " + WhereCondition.join_condition(*self._where)
+            for where in self._where:
+                query_with_table = where.query
+                for x in where._comparer:
+                    # TODOH []: Refactor this part. We need to get only the columns withouth __table_name__ preffix
+                    self._query += " " + query_with_table.replace(x.left_condition.table.__table_name__ + ".", "")
         return self._repository.execute_with_values(self._query, self._values)
 
     @override
-    def update(self, dicc: Any | dict[str | property, Any]) -> None:
+    def update[TProp](self, dicc: dict[str | ColumnType[TProp], Any]) -> None:
         if not isinstance(dicc, dict):
             raise TypeError
 
-        name_cols: list[Column] = []
-
+        col_names: list[Column] = []
+        CASTER = Caster(self._repository)
         for col, value in dicc.items():
-            col: Column = self._model.get_column(col, value)
+            if isinstance(col, str):
+                if not hasattr(self._model, col):
+                    raise UpdateKeyError(self._model, col)
+                col = getattr(self._model, col)
+            if not isinstance(col, Column):
+                raise ValueError
 
             if self.__is_valid__(col):
-                name_cols.append(col)
-                self._values.append(col.column_value_to_query)
+                clean_data = CASTER.for_value(value)
+                col_names.append((col.column_name,clean_data.wildcard_to_insert()))
+                self._values.append(clean_data.to_database)
 
-        set_query: str = ",".join(["=".join([col.column_name, col.placeholder]) for col in name_cols])
+        set_query: str = ",".join(["=".join(col_data) for col_data in col_names])
 
         self._query = f"{self.CLAUSE} {self._model.__table_name__} SET {set_query}"
         self._values = tuple(self._values)
         return None
 
     def __is_valid__(self, col: Column) -> bool:
+        if self._model is not col.table:
+            raise UpdateKeyError(self._model, col)
         return not col.is_auto_generated

ormlambda/databases/my_sql/clauses/upsert.py

@@ -2,13 +2,13 @@ from typing import override, Any
 
 from ormlambda import Table
 from ormlambda.components.upsert import UpsertQueryBase
-from ormlambda import IRepositoryBase
+from ormlambda.repository import IRepositoryBase
 from mysql.connector import MySQLConnection
 
 from .insert import InsertQuery
 
 
-class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase[MySQLConnection]]):
+class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase]):
     def __init__(self, model: T, repository: Any) -> None:
         super().__init__(model, repository)
 

ormlambda/databases/my_sql/clauses/where.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+import typing as tp
+from ormlambda.sql.comparer import Comparer
+from ormlambda.sql.clause_info import AggregateFunctionBase
+from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
+
+
+class Where(AggregateFunctionBase):
+    """
+    The purpose of this class is to create 'WHERE' condition queries properly.
+    """
+
+    def __init__(self, *comparer: Comparer, restrictive: bool = True, context: ClauseContextType = None) -> None:
+        self._comparer: tuple[Comparer] = comparer
+        self._restrictive: bool = restrictive
+        self._context: ClauseContextType = context if context else ClauseInfoContext()
+
+    @staticmethod
+    def FUNCTION_NAME() -> str:
+        return "WHERE"
+
+    @property
+    def query(self) -> str:
+        if isinstance(self._comparer, tp.Iterable):
+            context = ClauseInfoContext(table_context=self._context._table_context)
+            comparer = Comparer.join_comparers(self._comparer, restrictive=self._restrictive, context=context)
+        else:
+            comparer = self._comparer
+        return f"{self.FUNCTION_NAME()} {comparer}"
+
+    @property
+    def alias_clause(self) -> None:
+        return None
+
+    @staticmethod
+    def join_condition(wheres: tp.Iterable[Where], restrictive: bool, context: ClauseInfoContext) -> str:
+        if not isinstance(wheres, tp.Iterable):
+            wheres = (wheres,)
+
+        comparers: list[Comparer] = []
+        for where in wheres:
+            for c in where._comparer:
+                c.set_context(context)
+                comparers.append(c)
+        return Where(*comparers, restrictive=restrictive, context=context).query

ormlambda/databases/my_sql/functions/concat.py

@@ -1,41 +1,38 @@
-from ormlambda.common.interfaces.IAggregate import IAggregate
-from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase, ClauseInfo
+from ormlambda.sql.clause_info import AggregateFunctionBase
+from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
 
 
 import typing as tp
-from ormlambda.common.enums.join_type import JoinType
+from ormlambda.sql.types import ColumnType, AliasType
+from ormlambda.sql.clause_info import ClauseInfo
 
-if tp.TYPE_CHECKING:
-    from ormlambda import Table
 
+class Concat[*Ts](AggregateFunctionBase):
+    @staticmethod
+    def FUNCTION_NAME() -> str:
+        return "CONCAT"
 
-class Concat[T: tp.Type[Table]](DecompositionQueryBase[T], IAggregate[T]):
-    CLAUSE = "CONCAT"
-
-    def __init__[*Ts](
+    def __init__[TProp](
         self,
-        table: T,
-        lambda_query: str | tp.Callable[[T], tuple[*Ts]],
-        *,
-        alias: bool = True,
-        alias_name: str = "CONCAT",
-        by: JoinType = JoinType.INNER_JOIN,
+        values: ColumnType[Ts] | tuple[ColumnType[Ts], ...],
+        alias_clause: AliasType[ColumnType[TProp]] = "concat",
+        context: ClauseContextType = None,
     ) -> None:
         super().__init__(
-            table,
-            lambda_query,
-            alias=alias,
-            alias_name=alias_name,
-            by=by,
+            table=None,
+            column=values,
+            alias_clause=alias_clause,
+            context=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
-
+    @tp.override
     @property
     def query(self) -> str:
-        col: str = ", ".join([x.query for x in self.all_clauses])
+        columns: list[str] = []
+
+        context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
 
-        return f"{self.CLAUSE}({col})"
+        for clause in self._convert_into_clauseInfo(self.unresolved_column, context=context):
+            clause.alias_clause = None
+            columns.append(clause)
+        return self._concat_alias_and_column(f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns)})", self._alias_aggregate)

ormlambda/databases/my_sql/functions/max.py

@@ -1,39 +1,43 @@
-from ormlambda.common.interfaces import IAggregate
+from __future__ import annotations
 import typing as tp
 
-from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase, ClauseInfo
+from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
+from ormlambda.sql.clause_info import ClauseInfo
+from ormlambda.sql.types import ColumnType, AliasType
+from ormlambda.sql.clause_info import AggregateFunctionBase
 
-if tp.TYPE_CHECKING:
-    from ormlambda import Table
 
+class Max(AggregateFunctionBase[None]):
+    @staticmethod
+    def FUNCTION_NAME() -> str:
+        return "MAX"
 
-class Max[T: tp.Type[Table]](DecompositionQueryBase[T], IAggregate[T]):
-    NAME: str = "MAX"
-
-    @tp.overload
-    def __init__[T: tp.Type[Table]](self, table: T, column: tp.Callable[[T], tp.Any], *, alias: bool = True, alias_name: str = "max") -> None: ...
-
-    def __init__(
+    def __init__[TProp](
         self,
-        table: T,
-        column: str | tp.Callable[[T], tuple],
-        *,
-        alias: bool = True,
-        alias_name: str = "max",
-    ) -> None:
+        elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
+        alias_clause: AliasType[ColumnType[TProp]] = "max",
+        context: ClauseContextType = None,
+    ):
         super().__init__(
-            table,
-            lambda_query=column,
-            alias=alias,
-            alias_name=alias_name,
+            table=None,
+            column=elements,
+            alias_table=None,
+            alias_clause=alias_clause,
+            context=context,
+            keep_asterisk=False,
+            preserve_context=False,
         )
 
-    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
-
+    @tp.override
     @property
     def query(self) -> str:
-        col = ", ".join([x.query for x in self.all_clauses])
-        return f"{self.NAME}({col})"
+        columns: list[str] = []
+
+        context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
+        for clause in self._convert_into_clauseInfo(self.unresolved_column, context):
+            new_clause = clause
+            new_clause.alias_clause = None
+            columns.append(new_clause)
+
+        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns)})"
+        return self._concat_alias_and_column(method_string, self._alias_aggregate)

ormlambda/databases/my_sql/functions/min.py

@@ -1,39 +1,43 @@
-from ormlambda.common.interfaces import IAggregate
+from __future__ import annotations
 import typing as tp
 
-from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase, ClauseInfo
+from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
+from ormlambda.sql.clause_info import ClauseInfo
+from ormlambda.sql.types import ColumnType, AliasType
+from ormlambda.sql.clause_info import AggregateFunctionBase
 
-if tp.TYPE_CHECKING:
-    from ormlambda import Table
 
+class Min(AggregateFunctionBase):
+    @staticmethod
+    def FUNCTION_NAME() -> str:
+        return "MIN"
 
-class Min[T: tp.Type[Table]](DecompositionQueryBase[T], IAggregate[T]):
-    NAME: str = "MIN"
-
-    @tp.overload
-    def __init__[T: tp.Type[Table]](self, table: T, column: tp.Callable[[T], tp.Any], *, alias: bool = True, alias_name: str = "min") -> None: ...
-
-    def __init__(
+    def __init__[TProp](
         self,
-        table: T,
-        column: str | tp.Callable[[T], tuple],
-        *,
-        alias: bool = True,
-        alias_name: str = "min",
-    ) -> None:
+        elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
+        alias_clause: AliasType[ColumnType[TProp]] = "min",
+        context: ClauseContextType = None,
+    ):
         super().__init__(
-            table,
-            lambda_query=column,
-            alias=alias,
-            alias_name=alias_name,
+            table=None,
+            column=elements,
+            alias_table=None,
+            alias_clause=alias_clause,
+            context=context,
+            keep_asterisk=False,
+            preserve_context=False,
         )
 
-    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
-
+    @tp.override
     @property
     def query(self) -> str:
-        col = ", ".join([x.query for x in self.all_clauses])
-        return f"{self.NAME}({col})"
+        columns: list[str] = []
+
+        context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
+        for clause in self._convert_into_clauseInfo(self.unresolved_column, context):
+            new_clause = clause
+            new_clause.alias_clause = None
+            columns.append(new_clause)
+
+        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns)})"
+        return self._concat_alias_and_column(method_string, self._alias_aggregate)

ormlambda/databases/my_sql/functions/sum.py

@@ -1,39 +1,43 @@
-from ormlambda.common.interfaces import IAggregate
+from __future__ import annotations
 import typing as tp
 
-from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase, ClauseInfo
+from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
+from ormlambda.sql.clause_info import ClauseInfo
+from ormlambda.sql.types import ColumnType, AliasType
+from ormlambda.sql.clause_info import AggregateFunctionBase
 
-if tp.TYPE_CHECKING:
-    from ormlambda import Table
 
+class Sum(AggregateFunctionBase):
+    @staticmethod
+    def FUNCTION_NAME() -> str:
+        return "SUM"
 
-class Sum[T: tp.Type[Table]](DecompositionQueryBase[T], IAggregate[T]):
-    NAME: str = "SUM"
-
-    @tp.overload
-    def __init__[T: tp.Type[Table]](self, table: T, column: tp.Callable[[T], tp.Any], *, alias: bool = True, alias_name: str = ...) -> None: ...
-
-    def __init__(
+    def __init__[TProp](
         self,
-        table: T,
-        column: str | tp.Callable[[T], tuple],
-        *,
-        alias: bool = True,
-        alias_name: str = "sum",
-    ) -> None:
+        elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
+        alias_clause: AliasType[ColumnType[TProp]] = "sum",
+        context: ClauseContextType = None,
+    ):
         super().__init__(
-            table,
-            lambda_query=column,
-            alias=alias,
-            alias_name=alias_name,
+            table=None,
+            column=elements,
+            alias_table=None,
+            alias_clause=alias_clause,
+            context=context,
+            keep_asterisk=False,
+            preserve_context=False,
         )
 
-    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
-
+    @tp.override
     @property
     def query(self) -> str:
-        col = ", ".join([x.query for x in self.all_clauses])
-        return f"{self.NAME}({col})"
+        columns: list[str] = []
+
+        context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
+        for clause in self._convert_into_clauseInfo(self.unresolved_column, context):
+            new_clause = clause
+            new_clause.alias_clause = None
+            columns.append(new_clause)
+
+        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns)})"
+        return self._concat_alias_and_column(method_string, self._alias_aggregate)

ormlambda/databases/my_sql/join_context.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+from typing import Any, Iterable, TYPE_CHECKING
+
+from ormlambda import ForeignKey
+from ormlambda.sql.comparer import Comparer
+
+
+if TYPE_CHECKING:
+    from ormlambda.statements.interfaces.IStatements import IStatements_two_generic
+    from ormlambda.sql.clause_info import ClauseInfo
+    from ormlambda import Table
+    from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+    from ormlambda.common.enums.join_type import JoinType
+
+
+type TupleJoinType[LTable: Table, LProp, RTable: Table, RProp] = tuple[Comparer[LTable, LProp, RTable, RProp], JoinType]
+
+
+class JoinContext[TParent: Table, TRepo]:
+    def __init__(self, statements: IStatements_two_generic[TParent, TRepo], joins: tuple, context: ClauseContextType) -> None:
+        self._statements = statements
+        self._parent: TParent = statements.model
+        self._joins: Iterable[tuple[Comparer, JoinType]] = joins
+        self._context: ClauseContextType = context
+
+    def __enter__(self) -> IStatements_two_generic[TParent, TRepo]:
+        for comparer, by in self._joins:
+            fk_clause, alias = self.get_fk_clause(comparer)
+
+            foreign_key: ForeignKey = ForeignKey(comparer=comparer, clause_name=alias)
+            fk_clause.alias_table = foreign_key.alias
+            self._context.add_clause_to_context(fk_clause)
+            setattr(self._parent, alias, foreign_key)
+
+            # TODOH []: We need to preserve the 'foreign_key' variable while inside the 'with' clause.
+            # Keep in mind that 'ForeignKey.stored_calls' is cleared every time we call methods like
+            # .select(), .select_one(), .insert(), .update(), or .count(). This means we only retain
+            # the context from the first call of any of these methods.
+            ForeignKey.stored_calls.add(foreign_key)
+
+        return self
+
+    def __exit__(self, type: type, error: Any, traceback: str):
+        if error:
+            raise error
+
+        for comparer, _ in self._joins:
+            _, attribute = self.get_fk_clause(comparer)
+            fk: ForeignKey = getattr(self._parent, attribute)
+            delattr(self._parent, attribute)
+            del self._context._table_context[fk.tright]
+        return None
+
+    def __getattr__(self, name: str) -> TParent:
+        return getattr(self._parent, name)
+
+    def get_fk_clause(self, comparer: Comparer) -> tuple[ClauseInfo, str]:
+        """
+        In this method the 'comparer' attributes always should be a one by one comparison.
+        Not a combining of Comparers like when using () & () | () ... operator
+
+        >>> A.fk_b == B.pk_b # Correct
+        >>> (A.fk_b == B.pk_b) & (B.fk_c == C.pk_c) # Incorrect
+        """
+        clause_dicc: dict[Table, ClauseInfo] = {
+            comparer.left_condition.table: comparer.left_condition,
+            comparer.right_condition.table: comparer.right_condition,
+        }
+        conditions = set([comparer.left_condition.table, comparer.right_condition.table])
+        model = set([self._statements.model])
+
+        parent_table = conditions.difference(model).pop()
+
+        return clause_dicc[parent_table], clause_dicc[parent_table].table.__name__
+

ormlambda/databases/my_sql/repository/__init__.py

@@ -0,0 +1 @@
+from .repository import MySQLRepository  # noqa: F401