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

ormlambda/repository/response.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+from typing import Type, Any, TYPE_CHECKING, Optional
+from ormlambda.dialects.interface.dialect import Dialect
+import shapely as shp
+
+# Custom libraries
+from ormlambda.sql.clauses import Alias
+
+if TYPE_CHECKING:
+    from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
+    from ormlambda import Table
+    from ormlambda.sql.clauses import Select
+
+
+type TResponse[TFlavour, *Ts] = TFlavour | tuple[dict[str, tuple[*Ts]]] | tuple[tuple[*Ts]] | tuple[TFlavour]
+
+
+class Response[TFlavour, *Ts]:
+    def __init__(
+        self,
+        dialect: Dialect,
+        response_values: list[tuple[*Ts]],
+        columns: tuple[str],
+        flavour: Type[TFlavour],
+        select: Optional[Select] = None,
+    ) -> None:
+        self._dialect: Dialect = dialect
+        self._response_values: list[tuple[*Ts]] = response_values
+        self._columns: tuple[str] = columns
+        self._flavour: Type[TFlavour] = flavour
+        self._select: Select = select
+
+        self._response_values_index: int = len(self._response_values)
+
+        self._caster = dialect.caster()
+
+    @property
+    def is_one(self) -> bool:
+        return self._response_values_index == 1
+
+    @property
+    def is_there_response(self) -> bool:
+        return self._response_values_index != 0
+
+    @property
+    def is_many(self) -> bool:
+        return self._response_values_index > 1
+
+    def response(self, **kwargs) -> TResponse[TFlavour, *Ts]:
+        if not self.is_there_response:
+            return tuple([])
+
+        # Cast data using caster
+        cleaned_response = self._response_values
+
+        if self._select is not None:
+            cleaned_response = self._clean_response()
+
+        cast_flavour = self._cast_to_flavour(cleaned_response, **kwargs)
+
+        return tuple(cast_flavour)
+
+    def _cast_to_flavour(self, data: list[tuple[*Ts]], **kwargs) -> list[dict[str, tuple[*Ts]]] | list[tuple[*Ts]] | list[TFlavour]:
+        def _dict(**kwargs) -> list[dict[str, tuple[*Ts]]]:
+            nonlocal data
+            return [dict(zip(self._columns, x)) for x in data]
+
+        def _tuple(**kwargs) -> list[tuple[*Ts]]:
+            nonlocal data
+            return data
+
+        def _set(**kwargs) -> list[set]:
+            nonlocal data
+            for d in data:
+                n = len(d)
+                for i in range(n):
+                    try:
+                        hash(d[i])
+                    except TypeError:
+                        raise TypeError(f"unhashable type '{type(d[i])}' found in '{type(d)}' when attempting to cast the result into a '{set.__name__}' object")
+            return [set(x) for x in data]
+
+        def _list(**kwargs) -> list[list]:
+            nonlocal data
+            return [list(x) for x in data]
+
+        def _default(**kwargs) -> list[TFlavour]:
+            nonlocal data
+            replacer_dicc: dict[str, str] = {}
+
+            for col in self._select.all_clauses:
+                if hasattr(col, "_alias_aggregate") or col.alias_clause is None or isinstance(col, Alias):
+                    continue
+                replacer_dicc[col.alias_clause] = col.column
+
+            cleaned_column_names = [replacer_dicc.get(col, col) for col in self._columns]
+
+            result = []
+            for attr in data:
+                dicc_attr = dict(zip(cleaned_column_names, attr))
+                result.append(self._flavour(**dicc_attr, **kwargs))
+
+            return result
+
+        selector: dict[Type[object], Any] = {
+            dict: _dict,
+            tuple: _tuple,
+            set: _set,
+            list: _list,
+        }
+        return selector.get(self._flavour, _default)(**kwargs)
+
+    def _clean_response(self) -> TFlavour:
+        new_response: list[tuple] = []
+        for row in self._response_values:
+            new_row: list = []
+            for i, data in enumerate(row):
+                alias = self._columns[i]
+                clause_info = self._select[alias]
+                parse_data = self._caster.for_value(data, value_type=clause_info.dtype).from_database
+                new_row.append(parse_data)
+            new_row = tuple(new_row)
+            if not isinstance(new_row, tuple):
+                new_row = tuple(new_row)
+
+            new_response.append(new_row)
+        return new_response
+
+    @staticmethod
+    def _is_parser_required[T: Table](clause_info: ClauseInfo[T]) -> bool:
+        if clause_info is None:
+            return False
+
+        return clause_info.dtype is shp.Point

ormlambda/sql/clause_info/aggregate_function_base.py

@@ -16,6 +16,9 @@ from ormlambda.sql.table import TableMeta
 from .clause_info import ClauseInfo
 from .clause_info_context import ClauseContextType
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
 
 class AggregateFunctionBase[T: Table](ClauseInfo[T], IAggregate):
     def __init__[TProp: Column](
@@ -27,6 +30,10 @@ class AggregateFunctionBase[T: Table](ClauseInfo[T], IAggregate):
         context: ClauseContextType = None,
         keep_asterisk: bool = False,
         preserve_context: bool = False,
+        dtype: TProp = None,
+        *,
+        dialect: Dialect,
+        **kw,
     ):
         self._alias_aggregate = alias_clause
         super().__init__(
@@ -36,6 +43,9 @@ class AggregateFunctionBase[T: Table](ClauseInfo[T], IAggregate):
             context=context,
             keep_asterisk=keep_asterisk,
             preserve_context=preserve_context,
+            dtype=dtype,
+            dialect=dialect,
+            **kw,
         )
 
     @staticmethod
@@ -43,16 +53,16 @@ class AggregateFunctionBase[T: Table](ClauseInfo[T], IAggregate):
     def FUNCTION_NAME() -> str: ...
 
     @classmethod
-    def _convert_into_clauseInfo[TypeColumns, TProp](cls, columns: ClauseInfo | ColumnType[TProp], context: ClauseContextType) -> list[ClauseInfo]:
+    def _convert_into_clauseInfo[TypeColumns, TProp](cls, columns: ClauseInfo | ColumnType[TProp], context: ClauseContextType, dialect: Dialect) -> list[ClauseInfo]:
         type DEFAULT = tp.Literal["default"]
         type ClusterType = ColumnType | ForeignKey | DEFAULT
 
         dicc_type: dict[ClusterType, tp.Callable[[ClusterType], ClauseInfo]] = {
-            Column: lambda column: ClauseInfo(column.table, column, context=context),
+            Column: lambda column: ClauseInfo(column.table, column, context=context, dialect=dialect),
             ClauseInfo: lambda column: column,
-            ForeignKey: lambda tbl: ClauseInfo(tbl.tright, tbl.tright, context=context),
-            TableMeta: lambda tbl: ClauseInfo(tbl, tbl, context=context),
-            "default": lambda column: ClauseInfo(table=None, column=column, context=context),
+            ForeignKey: lambda tbl: ClauseInfo(tbl.tright, tbl.tright, context=context, dialect=dialect),
+            TableMeta: lambda tbl: ClauseInfo(tbl, tbl, context=context, dialect=dialect),
+            "default": lambda column: ClauseInfo(table=None, column=column, context=context, dialect=dialect),
         }
         all_clauses: list[ClauseInfo] = []
         if isinstance(columns, str) or not isinstance(columns, tp.Iterable):
@@ -63,8 +73,7 @@ class AggregateFunctionBase[T: Table](ClauseInfo[T], IAggregate):
         return all_clauses
 
     @tp.override
-    @property
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         wrapped_ci = self.wrapped_clause_info(self)
         if not self._alias_aggregate:
             return wrapped_ci
@@ -76,11 +85,12 @@ class AggregateFunctionBase[T: Table](ClauseInfo[T], IAggregate):
             context=self._context,
             keep_asterisk=self._keep_asterisk,
             preserve_context=self._preserve_context,
-        ).query
+            dialect=self._dialect,
+        ).query(dialect, **kwargs)
 
     def wrapped_clause_info(self, ci: ClauseInfo[T]) -> str:
         # avoid use placeholder when using IAggregate because no make sense.
         if self._alias_aggregate and (found := self._keyRegex.findall(self._alias_aggregate)):
             raise NotKeysInIAggregateError(found)
 
-        return f"{self.FUNCTION_NAME()}({ci._create_query()})"
+        return f"{self.FUNCTION_NAME()}({ci._create_query(self._dialect)})"

ormlambda/sql/clause_info/clause_info.py

@@ -12,11 +12,13 @@ from ormlambda.sql.types import (
 )
 from .interface import IClauseInfo
 from ormlambda.sql import ForeignKey
-from ormlambda.caster import Caster
 
 
 from .clause_info_context import ClauseInfoContext, ClauseContextType
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
 
 class ReplacePlaceholderError(ValueError):
     def __init__(self, placeholder: str, attribute: str, *args):
@@ -45,6 +47,11 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
     def __init__(self, table: TableType[T], keep_asterisk: tp.Optional[bool] = ...): ...
     @tp.overload
     def __init__(self, table: TableType[T], preserve_context: tp.Optional[bool] = ...): ...
+    @tp.overload
+    def __init__[TProp](self, table: TableType[T], dtype: tp.Optional[TProp] = ...): ...
+
+    @tp.overload
+    def __init__(self, dialect: Dialect, *args, **kwargs): ...
 
     def __init__[TProp](
         self,
@@ -55,6 +62,10 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         context: ClauseContextType = None,
         keep_asterisk: bool = False,
         preserve_context: bool = False,
+        dtype: tp.Optional[TProp] = None,
+        *,
+        dialect: Dialect,
+        **kw,
     ):
         if not self.is_table(table):
             column = table if not column else column
@@ -67,6 +78,9 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         self._context: ClauseContextType = context if context else ClauseInfoContext()
         self._keep_asterisk: bool = keep_asterisk
         self._preserve_context: bool = preserve_context
+        self._dtype = dtype
+
+        self._dialect: Dialect = dialect
 
         self._placeholderValues: dict[str, tp.Callable[[TProp], str]] = {
             "column": self.replace_column_placeholder,
@@ -76,8 +90,10 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         if not self._preserve_context and (self._context and any([alias_table, alias_clause])):
             self._context.add_clause_to_context(self)
 
+        super().__init__(**kw)
+
     def __repr__(self) -> str:
-        return f"{type(self).__name__}: query -> {self.query}"
+        return f"{type(self).__name__}: query -> {self.query(self._dialect)}"
 
     def replace_column_placeholder[TProp](self, column: ColumnType[TProp]) -> str:
         if not column:
@@ -140,6 +156,9 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
 
     @property
     def dtype[TProp](self) -> tp.Optional[tp.Type[TProp]]:
+        if self._dtype is not None:
+            return self._dtype
+
         if isinstance(self._column, Column):
             return self._column.dtype
 
@@ -147,11 +166,10 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
             return self._column
         return type(self._column)
 
-    @property
-    def query(self) -> str:
-        return self._create_query()
+    def query(self, dialect: Dialect, **kwargs) -> str:
+        return self._create_query(dialect, **kwargs)
 
-    def _create_query(self) -> str:
+    def _create_query(self, dialect: Dialect, **kwargs) -> str:
         # when passing some value that is not a column name
         if not self.table and not self._alias_clause:
             return self.column
@@ -173,10 +191,9 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         return self._join_table_and_column(self._column)
 
     def _join_table_and_column[TProp](self, column: ColumnType[TProp]) -> str:
-        # FIXME [ ]: Study how to deacoplate from mysql database
-        from ormlambda.databases.my_sql.repository import MySQLRepository
+        # FIXME [x]: Study how to deacoplate from mysql database
 
-        caster = Caster(MySQLRepository)
+        caster = self._dialect.caster()
 
         if self.alias_table:
             table = self._wrapped_with_quotes(self.alias_table)
@@ -213,22 +230,20 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
                 alias_clause=self._alias_clause,
                 context=self._context,
                 keep_asterisk=self._keep_asterisk,
+                dialect=self._dialect,
             )
 
         if self._alias_table and self._alias_clause:  # We'll add an "*" when we are certain that we have included 'alias_clause' attr
             return self._join_table_and_column(ASTERISK)
 
-        columns: list[ClauseInfo] = [ClauseCreator(column).query for column in self.table.get_columns()]
+        columns: list[ClauseInfo] = [ClauseCreator(column).query(self._dialect) for column in self.table.get_columns()]
 
         return ", ".join(columns)
 
-    # FIXME [ ]: Study how to deacoplate from mysql database
+    # FIXME [x]: Study how to deacoplate from mysql database
     def _column_resolver[TProp](self, column: ColumnType[TProp]) -> str:
-        from ormlambda.databases.my_sql.repository import MySQLRepository
-
-        caster = Caster(MySQLRepository)
         if isinstance(column, ClauseInfo):
-            return column.query
+            return column.query(self._dialect)
 
         if isinstance(column, tp.Iterable) and isinstance(column[0], ClauseInfo):
             return self.join_clauses(column)
@@ -249,6 +264,7 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         if self.is_foreign_key(self._column):
             return self._column.tright.__table_name__
 
+        caster = self._dialect.caster()
         casted_value = caster.for_value(column, self.dtype)
         if not self._table:
             # if we haven't some table atrribute, we assume that the user want to retrieve the string_data from caster.
@@ -292,12 +308,13 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         return self._context.get_table_alias(self.table)
 
     @staticmethod
-    def join_clauses(clauses: list[ClauseInfo[T]], chr: str = ",", context: tp.Optional[ClauseInfoContext] = None) -> str:
+    def join_clauses(clauses: list[ClauseInfo[T]], chr: str = ",", context: tp.Optional[ClauseInfoContext] = None, *, dialect: Dialect) -> str:
         queries: list[str] = []
         for c in clauses:
             if context:
                 c.context = context
-            queries.append(c.query)
+                c._dialect = dialect
+            queries.append(c.query(dialect))
 
         return f"{chr} ".join(queries)
 

ormlambda/sql/clauses/__init__.py

@@ -0,0 +1,14 @@
+from .alias import Alias  # noqa: F401
+from .count import Count  # noqa: F401
+from .delete import Delete  # noqa: F401
+from .group_by import GroupBy  # noqa: F401
+from .insert import Insert  # noqa: F401
+from .joins import JoinSelector  # noqa: F401
+from .limit import Limit  # noqa: F401
+from .offset import Offset  # noqa: F401
+from .order import Order  # noqa: F401
+from .select import Select  # noqa: F401
+from .where import Where  # noqa: F401
+from .having import Having  # noqa: F401
+from .update import Update  # noqa: F401
+from .upsert import Upsert  # noqa: F401

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

@@ -1,18 +1,21 @@
 from __future__ import annotations
 import typing as tp
 
-from ormlambda import Table
 from ormlambda.sql.clause_info import ClauseInfo
-from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
-from ormlambda.sql.types import TableType
+from ormlambda.sql.elements import ClauseElement
+
 
 if tp.TYPE_CHECKING:
-    from ormlambda.sql.types import ColumnType
     from ormlambda import Table
+    from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+    from ormlambda.sql.types import TableType
+    from ormlambda.sql.types import ColumnType
     from ormlambda.sql.types import AliasType
 
 
-class Alias[T: Table](ClauseInfo[T]):
+class Alias[T: Table](ClauseInfo[T], ClauseElement):
+    __visit_name__ = "alias"
+
     def __init__[TProp](
         self,
         table: TableType[T],
@@ -22,7 +25,21 @@ class Alias[T: Table](ClauseInfo[T]):
         context: ClauseContextType = None,
         keep_asterisk: bool = False,
         preserve_context: bool = False,
+        **kw,
     ):
         if not alias_clause:
             raise TypeError
-        super().__init__(table, column, alias_table, alias_clause, context, keep_asterisk, preserve_context)
+        super().__init__(
+            table,
+            column,
+            alias_table=alias_table,
+            alias_clause=alias_clause,
+            context=context,
+            keep_asterisk=keep_asterisk,
+            preserve_context=preserve_context,
+            dtype=None,
+            **kw,
+        )
+
+
+__all__ = ["Alias"]

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

@@ -9,13 +9,18 @@ from ormlambda import Table
 import typing as tp
 
 from ormlambda.sql.types import ASTERISK
+from ormlambda.sql.elements import ClauseElement
+
 
 if tp.TYPE_CHECKING:
     from ormlambda import Table
     from ormlambda.sql.types import ColumnType, AliasType, TableType
+    from ormlambda.dialects import Dialect
+
 
+class Count[T: Table](AggregateFunctionBase[T], ClauseElement):
+    __visit_name__ = "count"
 
-class Count[T: Table](AggregateFunctionBase[T]):
     @staticmethod
     def FUNCTION_NAME() -> str:
         return "COUNT"
@@ -28,6 +33,9 @@ class Count[T: Table](AggregateFunctionBase[T]):
         context: ClauseContextType = None,
         keep_asterisk: bool = True,
         preserve_context: bool = True,
+        *,
+        dialect: Dialect,
+        **kw,
     ) -> None:
         table = self.extract_table(element)
         column = element if self.is_column(element) else ASTERISK
@@ -40,4 +48,10 @@ class Count[T: Table](AggregateFunctionBase[T]):
             context=context,
             keep_asterisk=keep_asterisk,
             preserve_context=preserve_context,
+            dtype=int,
+            dialect=dialect,
+            **kw,
         )
+
+
+__all__ = ["Count"]

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

@@ -1,16 +1,22 @@
+from __future__ import annotations
 from typing import Any, Optional, override, Iterable, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ormlambda import Column
+    from ormlambda.engine import Engine
 
 from ormlambda import Table
-from ormlambda.repository import IRepositoryBase
-from ormlambda.components.delete import DeleteQueryBase
+from ormlambda import BaseRepository
+from ormlambda.sql.clauses.interfaces import IDelete
+from ormlambda.common.abstract_classes import NonQueryBase
+from ormlambda.sql.elements import ClauseElement
 
 
-class DeleteQuery[T: Table](DeleteQueryBase[T, IRepositoryBase]):
-    def __init__(self, model: T, repository: IRepositoryBase) -> None:
-        super().__init__(model, repository)
+class Delete[T: Table, TRepo](NonQueryBase[T, TRepo], IDelete[T], ClauseElement):
+    __visit_name__ = "delete"
+
+    def __init__(self, model: T, repository: BaseRepository[TRepo], engine: Engine) -> None:
+        super().__init__(model, repository, engine=engine)
 
     @property
     def CLAUSE(self) -> str:
@@ -24,7 +30,13 @@ class DeleteQuery[T: Table](DeleteQueryBase[T, IRepositoryBase]):
             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(instances[pk])
+
+            pk_value = instances[pk]
+
+            if not pk_value:
+                raise ValueError(f"primary key value '{pk_value}' must not be empty.")
+
+            value = str(pk_value)
 
         elif isinstance(instances, Iterable):
             value: list[Any] = []
@@ -53,4 +65,7 @@ class DeleteQuery[T: Table](DeleteQueryBase[T, IRepositoryBase]):
     def execute(self) -> None:
         if not self._query:
             raise ValueError
-        return self._repository.execute_with_values(self._query, self._values)
+        return self._engine.repository.execute_with_values(self._query, self._values)
+
+
+__all__ = ["Delete"]

ormlambda/sql/clauses/group_by.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+from ormlambda.sql.clause_info import AggregateFunctionBase, ClauseInfoContext
+from ormlambda.sql.types import ColumnType
+from ormlambda.sql.elements import ClauseElement
+
+
+class GroupBy(AggregateFunctionBase, ClauseElement):
+    __visit_name__ = "group_by"
+
+    @classmethod
+    def FUNCTION_NAME(self) -> str:
+        return "GROUP BY"
+
+    def __init__(self, column: ColumnType, context: ClauseInfoContext, dialect: Dialect, **kwargs):
+        super().__init__(
+            table=column.table,
+            column=column,
+            alias_table=None,
+            alias_clause=None,
+            context=context,
+            dialect=dialect,
+            **kwargs,
+        )
+
+
+__all__ = ["GroupBy"]

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

@@ -8,9 +8,14 @@ class Having(Where):
     The purpose of this class is to create 'WHERE' condition queries properly.
     """
 
-    def __init__(self, *comparer, restrictive=True, context=None):
-        super().__init__(*comparer, restrictive=restrictive, context=context)
+    __visit_name__ = "having"
+
+    def __init__(self, *comparer, restrictive=True, context=None, **kw):
+        super().__init__(*comparer, restrictive=restrictive, context=context, **kw)
 
     @staticmethod
     def FUNCTION_NAME() -> str:
         return "HAVING"
+
+
+__all__ = ["Having"]

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

@@ -4,17 +4,21 @@ from typing import override, Iterable, TYPE_CHECKING
 
 from ormlambda import Table
 from ormlambda import Column
-from ormlambda.components.insert import InsertQueryBase
-from ormlambda.repository import IRepositoryBase
-from ormlambda.caster import Caster
+
+from ormlambda.sql.clauses.interfaces import IInsert
+from ormlambda.common.abstract_classes import NonQueryBase
+from ormlambda.sql.elements import ClauseElement
+
 
 if TYPE_CHECKING:
-    from ormlambda.databases.my_sql import MySQLRepository
+    from ormlambda.dialects import Dialect
+
 
+class Insert[T: Table, TRepo](NonQueryBase[T, TRepo], IInsert[T], ClauseElement):
+    __visit_name__ = "insert"
 
-class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase]):
-    def __init__(self, model: T, repository: MySQLRepository) -> None:
-        super().__init__(model, repository)
+    def __init__(self, model: T, repository: TRepo, dialect: Dialect) -> None:
+        super().__init__(model, repository, dialect=dialect)
 
     @override
     @property
@@ -25,7 +29,7 @@ class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase]):
     def execute(self) -> None:
         if not self._query:
             raise ValueError
-        return self._repository.executemany_with_values(self.query, self._values)
+        return self._repository.executemany_with_values(self.query(self._dialect), self._values)
 
     @override
     def insert[TProp](self, instances: T | list[T]) -> None:
@@ -39,7 +43,7 @@ class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase]):
         col_values: list[list[str]] = []
         for i, cols in enumerate(valid_cols):
             col_values.append([])
-            CASTER = Caster(self._repository)
+            CASTER = self._dialect.caster()
             for col in cols:
                 clean_data = CASTER.for_column(col, instances[i])  # .resolve(instances[i][col])
                 if i == 0:
@@ -95,3 +99,6 @@ class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase]):
         else:
             raise Exception(f"Tipo de dato'{type(values)}' no esperado")
         return None
+
+
+__all__ = ["Insert"]

ormlambda/sql/clauses/interfaces/__init__.py

@@ -0,0 +1,5 @@
+from .IDelete import IDelete  # noqa: F401
+from .IInsert import IInsert  # noqa: F401
+from .ISelect import ISelect  # noqa: F401
+from .IUpdate import IUpdate  # noqa: F401
+from .IUpsert import IUpsert  # noqa: F401

ormlambda/{components → sql/clauses}/join/join_context.py

@@ -11,24 +11,32 @@ if TYPE_CHECKING:
     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
 
 
-type TupleJoinType[LTable: Table, LProp, RTable: Table, RProp] = tuple[Comparer[LTable, LProp, RTable, RProp], JoinType]
+type TupleJoinType[LTable: Table, LProp, RTable: Table, RProp] = tuple[Comparer]
 
 
 class JoinContext[TParent: Table, TRepo]:
-    def __init__(self, statements: IStatements_two_generic[TParent, TRepo], joins: tuple, context: ClauseContextType) -> None:
+    def __init__(
+        self,
+        statements: IStatements_two_generic[TParent, TRepo],
+        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]:
         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)
-            fk_clause.alias_table = foreign_key.alias
+            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)
 
@@ -64,10 +72,10 @@ class JoinContext[TParent: Table, TRepo]:
         >>> (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,
+            comparer.left_condition(self._dialect).table: comparer.left_condition(self._dialect),
+            comparer.right_condition(self._dialect).table: comparer.right_condition(self._dialect),
         }
-        conditions = set([comparer.left_condition.table, comparer.right_condition.table])
+        conditions = set([comparer.left_condition(self._dialect).table, comparer.right_condition(self._dialect).table])
         model = set([self._statements.model])
 
         parent_table = conditions.difference(model).pop()