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

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

@@ -0,0 +1 @@
+from .join_context import JoinContext, TupleJoinType  # noqa: F401

ormlambda/{databases/my_sql → 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()

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

@@ -3,20 +3,24 @@ from collections import defaultdict
 from typing import override, Optional, TYPE_CHECKING, Type
 
 
-from ormlambda.utils.module_tree.dfs_traversal import DFSTraversal
+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]):
+class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight], ClauseElement):
+    __visit_name__ = "join"
     __slots__: tuple = (
         "_comparer",
         "_orig_table",
@@ -37,26 +41,31 @@ class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight]):
 
     def __init__[LProp, RProp](
         self,
-        where: Comparer[TLeft, LProp, TRight, RProp],
+        where: Comparer,
         by: JoinType,
         alias: Optional[str] = "{table}",
         context: ClauseContextType = None,
+        *,
+        dialect: Dialect,
+        **kw,
     ) -> None:
-        self._comparer: Comparer[TLeft, LProp, TRight, RProp] = where
-        self._orig_table: TLeft = where.left_condition.table
-        self._right_table: TRight = where.right_condition.table
+        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 = where.left_condition._column.column_name
-        self._right_col: str = where.right_condition._column.column_name
+        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)
-        self._left_table_clause = ClauseInfo(self.left_table, column=self.left_col, alias_clause=None, context=self._create_partial_context())
-        self._right_table_clause = ClauseInfo(self.right_table, column=self.right_col, alias_clause=None, context=self._create_partial_context())
+        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__()
@@ -82,20 +91,18 @@ class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight]):
         return ClauseInfoContext(clause_context=None, table_context=self._context._table_context)
 
     @classmethod
-    def join_selectors(cls, *args: JoinSelector) -> str:
-        return "\n".join([x.query for x in args])
+    def join_selectors(cls, dialect: Dialect, *args: JoinSelector) -> str:
+        return "\n".join([x.query(dialect) for x in args])
 
-    @property
-    @override
-    def query(self) -> str:
+    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,
+            self._from_clause.query(dialect, **kwargs),
             "ON",
-            self._left_table_clause.query,
+            self._left_table_clause.query(dialect, **kwargs),
             self._compareop,  # =
-            self._right_table_clause.query,
+            self._right_table_clause.query(dialect, **kwargs),
         ]
         return " ".join([x for x in list_ if x is not None])
 
@@ -147,3 +154,6 @@ class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight]):
                 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/{databases/my_sql → sql}/clauses/order.py

@@ -1,14 +1,20 @@
 from __future__ import annotations
 import typing as tp
 
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
+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"
 
-class Order(AggregateFunctionBase):
     @staticmethod
     def FUNCTION_NAME() -> str:
         return "ORDER BY"
@@ -18,11 +24,16 @@ class Order(AggregateFunctionBase):
         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):
@@ -41,25 +52,4 @@ class Order(AggregateFunctionBase):
                 pass
         raise Exception(f"order_type param only can be 'ASC' or 'DESC' string or '{OrderType.__name__}' enum")
 
-    @tp.override
-    @property
-    def query(self) -> str:
-        string_columns: list[str] = []
-        columns = self.unresolved_column
-
-        # if this attr is not iterable means that we only pass one column without wrapped in a list or tuple
-        if isinstance(columns, str):
-            string_columns = f"{columns} {str(self._order_type[0])}"
-            return f"{self.FUNCTION_NAME()} {string_columns}"
-
-        if not isinstance(columns, tp.Iterable):
-            columns = (columns,)
-
-        assert len(columns) == len(self._order_type)
-
-        context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
-        for index, clause in enumerate(self._convert_into_clauseInfo(columns, context)):
-            clause.alias_clause = None
-            string_columns.append(f"{clause.query} {str(self._order_type[index])}")
-
-        return f"{self.FUNCTION_NAME()} {', '.join(string_columns)}"
+__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,11 +24,15 @@ 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
         # We always need to add the self alias of the Select
@@ -33,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/{databases/my_sql → sql}/clauses/update.py

@@ -1,11 +1,18 @@
-from typing import Type, override, Any
+from __future__ import annotations
+from typing import Type, override, Any, TYPE_CHECKING, Optional
 
-from ormlambda.components.update import UpdateQueryBase
 from ormlambda import Table, Column
-from ormlambda.repository import IRepositoryBase
 from ormlambda.caster.caster import Caster
 from .where import Where
-from ormlambda.sql.types import ColumnType
+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):
@@ -20,9 +27,12 @@ class UpdateKeyError(KeyError):
         return f"The column '{self._key}' does not belong to the table '{self._table.__table_name__}'. Please check the columns in the query."
 
 
-class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase]):
-    def __init__(self, model: T, repository: Any, where: list[Where]) -> None:
-        super().__init__(model, repository, where)
+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
@@ -33,11 +43,11 @@ class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase]):
     def execute(self) -> None:
         if self._where:
             for where in self._where:
-                query_with_table = where.query
+                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.table.__table_name__ + ".", "")
-        return self._repository.execute_with_values(self._query, self._values)
+                    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:
@@ -45,7 +55,7 @@ class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase]):
             raise TypeError
 
         col_names: list[Column] = []
-        CASTER = Caster(self._repository)
+        CASTER = self._engine.dialect.caster()
         for col, value in dicc.items():
             if isinstance(col, str):
                 if not hasattr(self._model, col):
@@ -69,3 +79,6 @@ class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase]):
         if self._model is not col.table:
             raise UpdateKeyError(self._model, col)
         return not col.is_auto_generated
+
+
+__all__ = ["Update"]

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

@@ -1,16 +1,22 @@
-from typing import override, Any
+from __future__ import annotations
+from typing import override, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda.engine import Engine
 
 from ormlambda import Table
-from ormlambda.components.upsert import UpsertQueryBase
-from ormlambda.repository import IRepositoryBase
-from mysql.connector import MySQLConnection
+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
 
-from .insert import InsertQuery
 
+class Upsert[T: Table, TRepo](NonQueryBase[T, TRepo], IUpsert[T], ClauseElement):
+    __visit_name__ = "upsert"
 
-class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase]):
-    def __init__(self, model: T, repository: Any) -> None:
-        super().__init__(model, repository)
+    def __init__(self, model: T, repository: BaseRepository[TRepo], engine: Engine) -> None:
+        super().__init__(model, repository, engine=engine)
 
     @override
     @property
@@ -19,7 +25,7 @@ class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase]):
 
     @override
     def execute(self) -> None:
-        return self._repository.executemany_with_values(self._query, self._values)
+        return self._engine.repository.executemany_with_values(self._query, self._values)
 
     @override
     def upsert(self, instances: T | list[T]) -> None:
@@ -50,7 +56,7 @@ class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase]):
         COL2 = _val.COL2;
 
         """
-        insert = InsertQuery[T](self._model, self._repository)
+        insert = Insert(self._model, self._engine.repository, self._engine.dialect)
         insert.insert(instances)
 
         if isinstance(instances, Table):
@@ -66,3 +72,6 @@ class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase]):
         self._query = query
         self._values = insert.values
         return None
+
+
+__all__ = ["Upsert"]