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

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/sql/clauses/count.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+from ormlambda.sql.clause_info import AggregateFunctionBase
+from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+
+from ormlambda.sql.types import AliasType, ColumnType
+
+from ormlambda import Table
+
+import typing as tp
+
+from ormlambda.sql.types import ASTERISK
+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"
+
+    @staticmethod
+    def FUNCTION_NAME() -> str:
+        return "COUNT"
+
+    def __init__[TProp: Table](
+        self,
+        element: ColumnType[T] | TableType[TProp],
+        alias_table: AliasType[ColumnType[TProp]] = None,
+        alias_clause: AliasType[ColumnType[TProp]] = "count",
+        context: ClauseContextType = None,
+        keep_asterisk: bool = True,
+        preserve_context: bool = True,
+        *,
+        dialect: Dialect,
+        **kw,
+    ) -> None:
+        table = self.extract_table(element)
+        column = element if self.is_column(element) else ASTERISK
+
+        super().__init__(
+            table=table if (alias_table or (context and table in context._table_context)) else None,
+            column=column,
+            alias_table=alias_table,
+            alias_clause=alias_clause,
+            context=context,
+            keep_asterisk=keep_asterisk,
+            preserve_context=preserve_context,
+            dtype=int,
+            dialect=dialect,
+            **kw,
+        )
+
+
+__all__ = ["Count"]

ormlambda/sql/clauses/delete.py

@@ -0,0 +1,71 @@
+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 import BaseRepository
+from ormlambda.sql.clauses.interfaces import IDelete
+from ormlambda.common.abstract_classes import NonQueryBase
+from ormlambda.sql.elements import ClauseElement
+
+
+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:
+        return "DELETE"
+
+    @override
+    def delete(self, instances: T | list[T]) -> None:
+        col: str = ""
+        if isinstance(instances, Table):
+            pk: Optional[Column] = instances.get_pk()
+            if pk is None:
+                raise Exception(f"You cannot use 'DELETE' query without set primary key in '{instances.__table_name__}'")
+            col = pk.column_name
+
+            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] = []
+            for ins in instances:
+                pk = type(ins).get_pk()
+                value.append(ins[pk])
+            col = pk.column_name
+
+        query: str = f"{self.CLAUSE} FROM {self._model.__table_name__} WHERE {col}"
+        if isinstance(value, str):
+            query += "= %s"
+            self._query = query
+            self._values = [value]
+            return None
+
+        elif isinstance(value, Iterable):
+            params = ", ".join(["%s"] * len(value))
+            query += f" IN ({params})"
+            self._query = query
+            self._values = value
+            return None
+        else:
+            raise Exception(f"'{type(value)}' no esperado")
+
+    @override
+    def execute(self) -> None:
+        if not self._query:
+            raise ValueError
+        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/sql/clauses/having.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from .where import Where
+
+
+class Having(Where):
+    """
+    The purpose of this class is to create 'WHERE' condition queries properly.
+    """
+
+    __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/sql/clauses/insert.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from typing import override, Iterable, TYPE_CHECKING
+
+from ormlambda import Table
+from ormlambda import Column
+
+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.dialects import Dialect
+
+
+class Insert[T: Table, TRepo](NonQueryBase[T, TRepo], IInsert[T], ClauseElement):
+    __visit_name__ = "insert"
+
+    def __init__(self, model: T, repository: TRepo, dialect: Dialect) -> None:
+        super().__init__(model, repository, dialect=dialect)
+
+    @override
+    @property
+    def CLAUSE(self) -> str:
+        return "INSERT INTO"
+
+    @override
+    def execute(self) -> None:
+        if not self._query:
+            raise ValueError
+        return self._repository.executemany_with_values(self.query(self._dialect), self._values)
+
+    @override
+    def insert[TProp](self, instances: T | list[T]) -> None:
+        if not isinstance(instances, Iterable):
+            instances = (instances,)
+        valid_cols: list[list[Column[TProp]]] = []
+        self.__fill_dict_list(valid_cols, instances)
+
+        col_names: list[str] = []
+        wildcards: list[str] = []
+        col_values: list[list[str]] = []
+        for i, cols in enumerate(valid_cols):
+            col_values.append([])
+            CASTER = self._dialect.caster()
+            for col in cols:
+                clean_data = CASTER.for_column(col, instances[i])  # .resolve(instances[i][col])
+                if i == 0:
+                    col_names.append(col.column_name)
+                    wildcards.append(clean_data.wildcard_to_insert())
+                # COMMENT: avoid MySQLWriteCastBase.resolve when using PLACEHOLDERs
+                col_values[-1].append(clean_data.to_database)
+
+        join_cols = ", ".join(col_names)
+        unknown_rows = f'({", ".join(wildcards)})'  # The number of "%s" must match the dict 'dicc_0' length
+
+        self._values = [tuple(x) for x in col_values]
+        self._query = f"{self.CLAUSE} {self._model.__table_name__} {f'({join_cols})'} VALUES {unknown_rows}"
+        return None
+
+    @staticmethod
+    def __is_valid[TProp](column: Column[TProp], value: TProp) -> bool:
+        """
+        We want to delete the column from table when it's specified with an 'AUTO_INCREMENT' or 'AUTO GENERATED ALWAYS AS (__) STORED' statement.
+
+        if the column is auto-generated, it means the database creates the value for that column, so we must deleted it.
+        if the column is primary key and auto-increment, we should be able to create an object with specific pk value.
+
+        RETURN
+        -----
+
+        - True  -> Do not delete the column from dict query
+        - False -> Delete the column from dict query
+        """
+
+        is_pk_none_and_auto_increment: bool = all([value is None, column.is_primary_key, column.is_auto_increment])
+
+        if is_pk_none_and_auto_increment or column.is_auto_generated:
+            return False
+        return True
+
+    def __fill_dict_list[TProp](self, list_dict: list[str, TProp], values: list[T]) -> list[Column]:
+        if isinstance(values, Iterable):
+            for x in values:
+                self.__fill_dict_list(list_dict, x)
+
+        elif issubclass(values.__class__, Table):
+            new_list = []
+            for prop in type(values).__dict__.values():
+                if not isinstance(prop, Column):
+                    continue
+
+                value = getattr(values, prop.column_name)
+                if self.__is_valid(prop, value):
+                    new_list.append(prop)
+            list_dict.append(new_list)
+
+        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()