ormlambda 3.12.2__py3-none-any.whl → 3.34.1__py3-none-any.whl

ormlambda/sql/clauses/joins.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+from collections import defaultdict
+from typing import override, Optional, TYPE_CHECKING, Type
+
+
+from ormlambda.util.module_tree.dfs_traversal import DFSTraversal
+from ormlambda.common.interfaces.IJoinSelector import IJoinSelector
+from ormlambda.common.interfaces.IQueryCommand import IQuery
+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
+from ormlambda.sql.elements import ClauseElement
+
+
+# TODOL [x]: Try to import Table module without circular import Error
+if TYPE_CHECKING:
+    from ormlambda import Table
+    from ormlambda.dialects import Dialect
+
+
+class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight], ClauseElement):
+    __visit_name__ = "join"
+    __slots__: tuple = (
+        "_comparer",
+        "_orig_table",
+        "_right_table",
+        "_by",
+        "_left_col",
+        "_right_col",
+        "_compareop",
+        "_alias",
+    )
+
+    @override
+    def __repr__(self) -> str:
+        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})"
+
+    def __init__[LProp, RProp](
+        self,
+        where: Comparer,
+        by: JoinType,
+        alias: Optional[str] = "{table}",
+        context: ClauseContextType = None,
+        *,
+        dialect: Dialect,
+        **kw,
+    ) -> None:
+        lcon = where.left_condition(dialect)
+        rcon = where.right_condition(dialect)
+        self._comparer: Comparer = where
+        self._orig_table: TLeft = lcon.table
+        self._right_table: TRight = rcon.table
+        self._by: JoinType = by
+        self._left_col: str = lcon._column.column_name
+        self._right_col: str = rcon._column.column_name
+        self._compareop = where._compare
+        self._context: ClauseContextType = context if context else ClauseInfoContext()
+
+        # COMMENT: When multiple columns reference the same table, we need to create an alias to maintain clear references.
+        self._alias: Optional[str] = alias
+
+        self._from_clause = ClauseInfo(self.right_table, alias_table=alias, context=self._context, dialect=dialect, **kw)
+        self._left_table_clause = ClauseInfo(self.left_table, column=self.left_col, alias_clause=None, context=self._create_partial_context(), dialect=dialect, **kw)
+        self._right_table_clause = ClauseInfo(self.right_table, column=self.right_col, alias_clause=None, context=self._create_partial_context(), dialect=dialect, **kw)
+
+    def __eq__(self, __value: JoinSelector) -> bool:
+        return isinstance(__value, JoinSelector) and self.__hash__() == __value.__hash__()
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.left_table,
+                self.right_table,
+                self._by,
+                self._left_col,
+                self._right_col,
+                self._compareop,
+            )
+        )
+
+    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, dialect: Dialect, *args: JoinSelector) -> str:
+        return "\n".join([x.query(dialect) for x in args])
+
+    def query(self, dialect: Dialect, **kwargs) -> str:
+        self._context = ClauseInfoContext(clause_context=None, table_context=self._context._table_context)
+        list_ = [
+            self._by.value,  # inner join
+            self._from_clause.query(dialect, **kwargs),
+            "ON",
+            self._left_table_clause.query(dialect, **kwargs),
+            self._compareop,  # =
+            self._right_table_clause.query(dialect, **kwargs),
+        ]
+        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]:
+        # 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.left_table].append(obj)
+
+        graph: dict[Type[Table], list[Type[Table]]] = defaultdict(list)
+        for join in joins:
+            graph[join.left_table].append(join.right_table)
+
+        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
+
+
+__all__ = ["JoinSelector"]

ormlambda/sql/clauses/limit.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from ormlambda.sql.elements import ClauseElement
+
+
+class Limit(ClauseElement):
+    __visit_name__ = "limit"
+    LIMIT = "LIMIT"
+
+    def __init__(self, number: int, **kwargs) -> None:
+        if not isinstance(number, int):
+            raise ValueError
+        self._number: int = number
+
+
+__all__ = ["Limit"]

ormlambda/sql/clauses/offset.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from ormlambda.sql.elements import ClauseElement
+
+
+class Offset(ClauseElement):
+    __visit_name__ = "offset"
+    OFFSET = "OFFSET"
+
+    def __init__(self, number: int, **kwargs) -> None:
+        if not isinstance(number, int):
+            raise ValueError
+        self._number: int = number
+
+
+__all__ = ["Offset"]

ormlambda/sql/clauses/order.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+import typing as tp
+
+from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+from ormlambda.sql.types import ColumnType
+from ormlambda.sql.clause_info import AggregateFunctionBase
+
+from ormlambda.statements import OrderType
+from ormlambda.sql.elements import ClauseElement
+
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
+
+class Order(AggregateFunctionBase, ClauseElement):
+    __visit_name__ = "order"
+
+    @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,
+        *,
+        dialect: Dialect,
+        **kw,
+    ):
+        super().__init__(
+            table=None,
+            column=column,
+            context=context,
+            dialect=dialect,
+            **kw,
+        )
+
+        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: tp.Any) -> tp.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")
+
+__all__ = ["Order"]

ormlambda/{databases/my_sql → sql}/clauses/select.py

@@ -1,17 +1,20 @@
 from __future__ import annotations
-from typing import Optional, override, Type, Callable, TYPE_CHECKING
+from ormlambda.sql.elements import ClauseElement
+from typing import Optional, 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.components import ISelect
 
 if TYPE_CHECKING:
     from ormlambda import Table
+    from ormlambda.dialects import Dialect
 
 
-class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ISelect):
+class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ClauseElement):
+    __visit_name__ = "select"
+
     CLAUSE: str = "SELECT"
 
     def __init__(
@@ -21,12 +24,14 @@ class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ISelect):
         *,
         alias_table: AliasType[ClauseInfo] = "{table}",
         context: Optional[ClauseInfoContext] = None,
+        dialect: Dialect,
         **kwargs,
     ) -> None:
         super().__init__(
             tables,
             columns,
             context=context,
+            dialect=dialect,
             **kwargs,
         )
         self._alias_table = alias_table
@@ -35,18 +40,12 @@ class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ISelect):
 
     @property
     def FROM(self) -> ClauseInfo[T]:
-        return ClauseInfo(self.table, None, alias_table=self._alias_table, context=self._context)
+        return ClauseInfo(self.table, None, alias_table=self._alias_table, context=self._context, dialect=self._dialect, **self.kwargs)
 
     @property
     def COLUMNS(self) -> str:
-        return ClauseInfo.join_clauses(self._all_clauses, ",", self.context)
+        dialect = self.kwargs.pop("dialect", self._dialect)
+        return ClauseInfo.join_clauses(self._all_clauses, ",", self.context, dialect=dialect)
 
-    # TODOL: see who to deal when we will have to add more mysql methods
-    @override
-    @property
-    def query(self) -> str:
-        # COMMENT: (select.query, query)We must first create an alias for 'FROM' and then define all the remaining clauses.
-        # This order is mandatory because it adds the clause name to the context when accessing the .query property of 'FROM'
-        FROM = self.FROM
 
-        return f"{self.CLAUSE} {self.COLUMNS} FROM {FROM.query}"
+__all__ = ["Select"]

ormlambda/sql/clauses/update.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+from typing import Type, override, Any, TYPE_CHECKING, Optional
+
+from ormlambda import Table, Column
+from ormlambda.caster.caster import Caster
+from .where import Where
+from ormlambda.common.abstract_classes import NonQueryBase
+from .interfaces import IUpdate
+
+if TYPE_CHECKING:
+    from ormlambda.sql.types import ColumnType
+    from .where import Where
+    from ormlambda.engine import Engine
+
+from ormlambda.sql.elements import ClauseElement
+
+
+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 Update[T: Type[Table], TRepo](NonQueryBase[T, TRepo], IUpdate, ClauseElement):
+    __visit_name__ = "update"
+
+    def __init__(self, model: T, repository: Any, where: list[Where], engine: Engine) -> None:
+        super().__init__(model, repository, engine=engine)
+        self._where: Optional[list[Where]] = where
+
+    @override
+    @property
+    def CLAUSE(self) -> str:
+        return "UPDATE"
+
+    @override
+    def execute(self) -> None:
+        if self._where:
+            for where in self._where:
+                query_with_table = where.query(self._engine.dialect)
+                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(self._dialect).table.__table_name__ + ".", "")
+        return self._engine.repository.execute_with_values(self._query, self._values)
+
+    @override
+    def update[TProp](self, dicc: dict[str | ColumnType[TProp], Any]) -> None:
+        if not isinstance(dicc, dict):
+            raise TypeError
+
+        col_names: list[Column] = []
+        CASTER = self._engine.dialect.caster()
+        for col, value in dicc.items():
+            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):
+                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_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
+
+
+__all__ = ["Update"]

ormlambda/sql/clauses/upsert.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+from typing import override, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda.engine import Engine
+
+from ormlambda import Table
+from ormlambda.repository import BaseRepository
+from ormlambda.sql.clauses.interfaces import IUpsert
+from ormlambda.common.abstract_classes import NonQueryBase
+from .insert import Insert
+from ormlambda.sql.elements import ClauseElement
+
+
+class Upsert[T: Table, TRepo](NonQueryBase[T, TRepo], IUpsert[T], ClauseElement):
+    __visit_name__ = "upsert"
+
+    def __init__(self, model: T, repository: BaseRepository[TRepo], engine: Engine) -> None:
+        super().__init__(model, repository, engine=engine)
+
+    @override
+    @property
+    def CLAUSE(self) -> str:
+        return "ON DUPLICATE KEY UPDATE"
+
+    @override
+    def execute(self) -> None:
+        return self._engine.repository.executemany_with_values(self._query, self._values)
+
+    @override
+    def upsert(self, instances: T | list[T]) -> None:
+        """
+        Esta funcion se enfoca para trabajar con listas, aunque el argumneto changes sea un unico diccionario.
+
+        Accedemos a la primera posicion de la lista 'changes[0]' porque en la query solo estamos poniendo marcadores de posicion, alias y nombres de columnas
+
+        EXAMPLE
+        ------
+
+        MySQL
+        -----
+
+        INSERT INTO NAME_TABLE(PK_COL,COL2)
+        VALUES
+        (1,'PABLO'),
+        (2,'MARINA') AS _val
+        ON DUPLICATE KEY UPDATE
+        COL2 = _val.COL2;
+
+        Python
+        -----
+
+        INSERT INTO NAME_TABLE(PK_COL,COL2)
+        VALUES (%s, %s') AS _val
+        ON DUPLICATE KEY UPDATE
+        COL2 = _val.COL2;
+
+        """
+        insert = Insert(self._model, self._engine.repository, self._engine.dialect)
+        insert.insert(instances)
+
+        if isinstance(instances, Table):
+            instances = tuple([instances])
+        ALIAS = "VALUES"
+
+        cols = instances[0].get_columns()
+        pk_key = instances[0].get_pk().column_name
+
+        alternative = ", ".join([f"{col}={ALIAS}({col})" for col in cols if col != pk_key])
+        query = f"{insert._query} {self.CLAUSE} {alternative};"
+
+        self._query = query
+        self._values = insert.values
+        return None
+
+
+__all__ = ["Upsert"]

ormlambda/sql/clauses/where.py

@@ -0,0 +1,65 @@
+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
+from ormlambda.sql.elements import ClauseElement
+
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
+
+class Where(AggregateFunctionBase, ClauseElement):
+    """
+    The purpose of this class is to create 'WHERE' condition queries properly.
+    """
+
+    __visit_name__ = "where"
+
+    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"
+
+    def query(self, dialect: Dialect, **kwargs) -> 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,
+                dialect=dialect,
+                **kwargs,
+            )
+        else:
+            comparer = self._comparer
+        return f"{self.FUNCTION_NAME()} {comparer}"
+
+    @property
+    def alias_clause(self) -> None:
+        return None
+
+    @classmethod
+    def join_condition(cls, wheres: tp.Iterable[Where], restrictive: bool, context: ClauseInfoContext, dialect: Dialect = None) -> str:
+        if not isinstance(wheres, tp.Iterable):
+            wheres = (wheres,)
+
+        comparers: list[Comparer] = []
+        for where in wheres:
+            for c in where._comparer:
+                if not c._context:
+                    c._context = context
+                comparers.append(c)
+        return cls(*comparers, restrictive=restrictive, context=context).query(dialect=dialect)
+
+
+__all__ = ["Where"]

ormlambda/sql/column/__init__.py

@@ -0,0 +1 @@
+from .column import Column  # noqa: F401