ormlambda 3.35.3__py3-none-any.whl → 4.0.4__py3-none-any.whl

ormlambda/sql/clauses/join/join_context.py

@@ -6,10 +6,9 @@ from ormlambda.sql.comparer import Comparer
 
 
 if TYPE_CHECKING:
-    from ormlambda.statements.interfaces.IStatements import IStatements_two_generic
+    from ormlambda.statements.interfaces.IStatements import IStatements
     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
     from ormlambda.dialects import Dialect
 
@@ -17,34 +16,31 @@ if TYPE_CHECKING:
 type TupleJoinType[LTable: Table, LProp, RTable: Table, RProp] = tuple[Comparer]
 
 
-class JoinContext[TParent: Table, TRepo]:
+class JoinContext[TParent: Table]:
     def __init__(
         self,
-        statements: IStatements_two_generic[TParent, TRepo],
+        statements: IStatements[TParent],
         joins: tuple,
-        context: ClauseContextType,
         dialect: Dialect,
     ) -> None:
         self._statements = statements
         self._parent: TParent = statements.model
         self._joins: Iterable[tuple[Comparer, JoinType]] = joins
-        self._context: ClauseContextType = context
         self._dialect: Dialect = dialect
 
-    def __enter__(self) -> IStatements_two_generic[TParent, TRepo]:
+    def __enter__(self) -> IStatements[TParent]:
         for comparer, by in self._joins:
             fk_clause, alias = self.get_fk_clause(comparer)
 
             foreign_key: ForeignKey = ForeignKey(comparer=comparer, clause_name=alias, keep_alive=True, dialect=self._dialect)
             fk_clause.alias_table = foreign_key.get_alias(self._dialect)
-            self._context.add_clause_to_context(fk_clause)
             setattr(self._parent, alias, foreign_key)
 
             # TODOH [x]: 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)
+            # FIXME [ ]: See how to deal with context when using JoinContext class and PATH_CONTEXT
 
         return self
 
@@ -54,10 +50,7 @@ class JoinContext[TParent: Table, TRepo]:
 
         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]
-            ForeignKey.stored_calls.remove(fk)
         return None
 
     def __getattr__(self, name: str) -> TParent:

ormlambda/sql/clauses/joins.py

@@ -1,15 +1,13 @@
 from __future__ import annotations
 from collections import defaultdict
-from typing import override, Optional, TYPE_CHECKING, Type
+from typing import override, Optional, TYPE_CHECKING
 
 
 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 import ColumnProxy, JoinType
 from ormlambda.sql.comparer import Comparer
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
 from ormlambda.sql.elements import ClauseElement
 
 
@@ -34,78 +32,41 @@ class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight], Cl
 
     @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})"
+        return f"{IQuery.__name__}: {self.__class__.__name__} ({self.alias})"
 
     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.lcon: ColumnProxy = where.left_condition
+        self.rcon: ColumnProxy = where.right_condition
         self._comparer: Comparer = where
-        self._orig_table: TLeft = lcon.table
-        self._right_table: TRight = rcon.table
+        self._orig_table: TLeft = self.lcon.table
+        self._right_table: TRight = self.rcon.table
         self._by: JoinType = by
-        self._left_col: str = lcon._column.column_name
-        self._right_col: str = rcon._column.column_name
+        self._left_col: str = self.lcon._column.column_name
+        self._right_col: str = self.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)
+        # Only can add the first instance of a JoinsSelector which has the same alias
+        return hash(self.alias)
 
     @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
@@ -137,9 +98,9 @@ class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight], Cl
         for obj in joins:
             join_object_map[obj.left_table].append(obj)
 
-        graph: dict[Type[Table], list[Type[Table]]] = defaultdict(list)
+        graph: dict[str, list[str]] = defaultdict(list)
         for join in joins:
-            graph[join.left_table].append(join.right_table)
+            graph[join.alias].append(join.right_table.__table_name__)
 
         sorted_graph = DFSTraversal.sort(graph)[::-1]
 
@@ -155,5 +116,26 @@ class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight], Cl
             res.extend(tables)
         return res
 
+    @classmethod
+    def sort_joins_by_alias(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, JoinSelector] = {}
+
+        for obj in joins:
+            join_object_map[obj.alias] = obj
+
+        sorted_graph = []
+
+        for alias in sorted([x.alias for x in joins]):
+            sorted_graph.append(join_object_map[alias])
+
+        if not sorted_graph:
+            return tuple(joins)
+
+        return tuple(sorted_graph)
+
 
 __all__ = ["JoinSelector"]

ormlambda/sql/clauses/limit.py

@@ -4,9 +4,8 @@ from ormlambda.sql.elements import ClauseElement
 
 class Limit(ClauseElement):
     __visit_name__ = "limit"
-    LIMIT = "LIMIT"
 
-    def __init__(self, number: int, **kwargs) -> None:
+    def __init__(self, number: int) -> None:
         if not isinstance(number, int):
             raise ValueError
         self._number: int = number

ormlambda/sql/clauses/offset.py

@@ -4,9 +4,8 @@ from ormlambda.sql.elements import ClauseElement
 
 class Offset(ClauseElement):
     __visit_name__ = "offset"
-    OFFSET = "OFFSET"
 
-    def __init__(self, number: int, **kwargs) -> None:
+    def __init__(self, number: int) -> None:
         if not isinstance(number, int):
             raise ValueError
         self._number: int = number

ormlambda/sql/clauses/order.py

@@ -1,44 +1,33 @@
 from __future__ import annotations
 import typing as tp
 
-from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+from ormlambda.sql.clause_info import IAggregate
 from ormlambda.sql.types import ColumnType
-from ormlambda.sql.clause_info import AggregateFunctionBase
 
-from ormlambda.statements import OrderType
+from ormlambda.common.enums import OrderType
 from ormlambda.sql.elements import ClauseElement
 
 if tp.TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
+    from ormlambda import ColumnProxy
 
 
-class Order(AggregateFunctionBase, ClauseElement):
+class Order[TProp](ClauseElement, IAggregate):
     __visit_name__ = "order"
 
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "ORDER BY"
+    columns: tuple[ColumnType[TProp], ...]
 
-    def __init__[TProp](
+    def __init__(
         self,
-        column: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
+        *columns: ColumnProxy[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(columns, str) or not isinstance(columns, tp.Iterable):
+            columns = (columns,)
 
         if isinstance(order_type, str) or not isinstance(order_type, tp.Iterable):
             order_type = (order_type,)
 
+        self.columns = columns
         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]:
@@ -52,4 +41,11 @@ class Order(AggregateFunctionBase, ClauseElement):
                 pass
         raise Exception(f"order_type param only can be 'ASC' or 'DESC' string or '{OrderType.__name__}' enum")
 
+    def used_columns(self):
+        return self.columns
+
+    @property
+    def dtype(self) -> tp.Any: ...
+
+
 __all__ = ["Order"]

ormlambda/sql/clauses/select.py

@@ -1,51 +1,79 @@
 from __future__ import annotations
+from ormlambda import ColumnProxy
 from ormlambda.sql.elements import ClauseElement
-from typing import Optional, Type, Callable, TYPE_CHECKING
+from typing import Any, Iterable, Optional, Type, 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.sql.clause_info import ClauseInfo, IAggregate
+from ormlambda.sql.types import SelectCol
+from ormlambda.sql.table import TableProxy
 
 if TYPE_CHECKING:
+    from ormlambda.sql.types import AliasType, ColumnType
     from ormlambda import Table
-    from ormlambda.dialects import Dialect
 
+type Selectable = ColumnType | TableProxy
 
-class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ClauseElement):
-    __visit_name__ = "select"
 
-    CLAUSE: str = "SELECT"
+class Select[T: Type[Table]](ClauseElement, IAggregate):
+    __visit_name__ = "select"
 
     def __init__(
         self,
-        tables: tuple[T, *Ts],
-        columns: Callable[[T], tuple] = lambda x: x,
+        table: T,
+        columns: SelectCol,
         *,
         alias_table: AliasType[ClauseInfo] = "{table}",
-        context: Optional[ClauseInfoContext] = None,
-        dialect: Dialect,
-        **kwargs,
+        alias: Optional[AliasType[T]] = None,
+        avoid_duplicates: bool = False,
     ) -> None:
-        super().__init__(
-            tables,
-            columns,
-            context=context,
-            dialect=dialect,
-            **kwargs,
-        )
+        self._table = table
+        self._columns = columns
         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)
+        self._alias = alias
+        self._avoid_duplicates = avoid_duplicates
+
+    @property
+    def columns(self) -> tuple[SelectCol, ...]:
+        if not isinstance(self._columns, Iterable):
+            return [self._columns]
+        return self._columns
 
     @property
-    def FROM(self) -> ClauseInfo[T]:
-        return ClauseInfo(self.table, None, alias_table=self._alias_table, context=self._context, dialect=self._dialect, **self.kwargs)
+    def table(self) -> TableProxy[T]:
+        return TableProxy(self._table)
+
+    @property
+    def alias(self) -> str:
+        return self._alias
+
+    @alias.setter
+    def alias(self, value) -> None:
+        self._alias = value
 
     @property
-    def COLUMNS(self) -> str:
-        dialect = self.kwargs.pop("dialect", self._dialect)
-        return ClauseInfo.join_clauses(self._all_clauses, ",", self.context, dialect=dialect)
+    def avoid_duplicates(self) -> bool:
+        return self._avoid_duplicates
+
+    def used_columns(self):
+        res = []
+
+        for col in self._columns:
+            if isinstance(col, ColumnProxy):
+                res.append(col)
+
+            elif isinstance(col, IAggregate):
+                res.extend(col.used_columns())
+        return res
+
+    @property
+    def dtype(self) -> Any: ...
+
+    def __getitem__(self, key: str) -> SelectCol:
+        for clause in self.columns:
+            if isinstance(clause, ColumnProxy) and key in (clause.column_name, clause.alias, clause.get_full_chain("_")):
+                return clause
+            if isinstance(clause, IAggregate) and key == clause.alias:
+                return clause
 
 
 __all__ = ["Select"]

ormlambda/sql/clauses/update.py

@@ -1,8 +1,7 @@
 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 ormlambda import Table, Column, ColumnProxy
 from .where import Where
 from ormlambda.common.abstract_classes import NonQueryBase
 from .interfaces import IUpdate
@@ -30,9 +29,15 @@ class UpdateKeyError(KeyError):
 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:
+    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
+        self._where: Optional[Where] = where
 
     @override
     @property
@@ -42,11 +47,9 @@ class Update[T: Type[Table], TRepo](NonQueryBase[T, TRepo], IUpdate, ClauseEleme
     @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__ + ".", "")
+            where_string = self._where.compile(self._engine.dialect).string
+
+            self._query += " " + where_string
         return self._engine.repository.execute_with_values(self._query, self._values)
 
     @override
@@ -61,7 +64,7 @@ class Update[T: Type[Table], TRepo](NonQueryBase[T, TRepo], IUpdate, ClauseEleme
                 if not hasattr(self._model, col):
                     raise UpdateKeyError(self._model, col)
                 col = getattr(self._model, col)
-            if not isinstance(col, Column):
+            if not isinstance(col, Column | ColumnProxy):
                 raise ValueError
 
             if self.__is_valid__(col):

ormlambda/sql/clauses/where.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 import typing as tp
+from ormlambda import ColumnProxy
 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
+    from ormlambda.statements.types import WhereTypes
 
 
-class Where(AggregateFunctionBase, ClauseElement):
+class Where[T](ClauseElement):
     """
     The purpose of this class is to create 'WHERE' condition queries properly.
     """
@@ -18,48 +17,30 @@ class Where(AggregateFunctionBase, ClauseElement):
 
     def __init__(
         self,
-        *comparer: Comparer,
+        *comparer: WhereTypes,
         restrictive: bool = True,
-        context: ClauseContextType = None,
     ) -> None:
-        self._comparer: tuple[Comparer] = comparer
-        self._restrictive: bool = restrictive
-        self._context: ClauseContextType = context if context else ClauseInfoContext()
+        self.comparer: set[Comparer] = set(comparer)
+        self.restrictive: bool = restrictive
 
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "WHERE"
+    def used_columns(self) -> tp.Iterable[ColumnProxy]:
+        res = []
 
-    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}"
+        for comparer in self.comparer:
+            if isinstance(comparer.left_condition, ColumnProxy):
+                res.append(comparer.left_condition)
 
-    @property
-    def alias_clause(self) -> None:
-        return None
+            if isinstance(comparer.right_condition, ColumnProxy):
+                res.append(comparer.right_condition)
 
-    @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,)
+        return res
 
-        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)
+    def add_comparers(self, comparers: tp.Iterable[Comparer]) -> None:
+        if not isinstance(comparers, tp.Iterable):
+            comparers = [comparers]
+
+        for comparer in comparers:
+            self.comparer.add(comparer)
 
 
 __all__ = ["Where"]

ormlambda/sql/column/__init__.py

@@ -1 +1,2 @@
 from .column import Column  # noqa: F401
+from .column_proxy import ColumnProxy  # noqa: F401

ormlambda/sql/column/column.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
-import abc
-from typing import Annotated, Any, ClassVar, Iterable, Type, Optional, TYPE_CHECKING, get_type_hints, overload, get_origin, get_args
-from ormlambda.sql.types import TableType, ComparerType, ColumnType
+from typing import Annotated, Any, Iterable, Type, Optional, TYPE_CHECKING, get_type_hints, overload, get_origin, get_args, ClassVar
+from ormlambda.sql.elements import ClauseElement
+from ormlambda.sql.types import TableType, ComparerType, ColumnType, TypeEngine
 from ormlambda import ConditionType
-from ormlambda.sql.type_api import TypeEngine
+from ormlambda import util
 
 if TYPE_CHECKING:
     import re
@@ -23,7 +23,8 @@ from ormlambda.types import (
 )
 
 
-class Column[TProp]:
+class Column[TProp](ClauseElement):
+    __visit_name__ = "column"
     PRIVATE_CHAR: ClassVar[str] = "_"
 
     _dbtype: Optional[TypeEngine]
@@ -44,6 +45,8 @@ class Column[TProp]:
         "_check",
     )
 
+    table: Type[Table]
+
     @overload
     def __init__(self, *, column_name: str): ...
 
@@ -100,8 +103,8 @@ class Column[TProp]:
     def __str__(self) -> str:
         return self.table.__table_name__ + "." + self.column_name
 
-    def __set_name__[T: Table](self, owner: TableType[T], name: str) -> None:
-        self.table: TableType[T] = owner
+    def __set_name__(self, owner: TableType[Table], name: str) -> None:
+        self.table: TableType[Table] = owner
         self.column_name = name
         self.__private_name = self.PRIVATE_CHAR + name
 
@@ -133,9 +136,12 @@ class Column[TProp]:
             )
         )
 
+    @util.preload_module("ormlambda.sql.type_api")
     def _fill_from_annotations[T: Table](self, obj: Type[T], name: str) -> None:
         """Read the metada when using Annotated typing class, and set the attributes accordingly"""
 
+        TypeEngine = util.preloaded.sql_type_api.TypeEngine
+
         annotations = get_type_hints(obj, include_extras=True)
         if name in annotations:
             annotation = annotations[name]
@@ -182,9 +188,9 @@ class Column[TProp]:
     def dbtype(self) -> TypeEngine[TProp]:
         return self._dbtype if self._dbtype else self.dtype
 
-    @abc.abstractmethod
+    @util.preload_module("ormlambda.sql.comparer")
     def __comparer_creator(self, other: ColumnType, compare: ComparerType) -> Comparer:
-        from ormlambda.sql.comparer import Comparer
+        Comparer = util.preloaded.sql_comparer.Comparer
 
         return Comparer(self, other, compare)
 
@@ -215,20 +221,21 @@ class Column[TProp]:
     def not_contains(self, other: ColumnType) -> Comparer:
         return self.__comparer_creator(other, ConditionType.NOT_IN.value)
 
+    @util.preload_module("ormlambda.sql.comparer")
     def regex(self, pattern: str, flags: Optional[re.RegexFlag | Iterable[re.RegexFlag]] = None) -> Regex:
-        from ormlambda.sql.comparer import Regex
+        Regex = util.preloaded.sql_comparer.Regex
 
         if not isinstance(flags, Iterable):
             flags = (flags,)
         return Regex(
             left_condition=self,
             right_condition=pattern,
-            context=None,
             flags=flags,
         )
 
+    @util.preload_module("ormlambda.sql.comparer")
     def like(self, pattern: str) -> Like:
-        from ormlambda.sql.comparer import Like
+        Like = util.preloaded.sql_comparer.Like
 
         return Like(self, pattern)