ormlambda 1.0.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

ormlambda/__init__.py

@@ -1,4 +1,10 @@
-from .model_base import BaseModel  # noqa: F401
+# enums
+from .common.enums import (  # noqa: F401
+    JoinType,
+    ConditionType,
+)
+
+from .common.interfaces import IRepositoryBase  # noqa: F401
 from .utils import Table, Column, ForeignKey  # noqa: F401
 from .utils.lambda_disassembler import Disassembler, nameof  # noqa: F401
-from .common.interfaces import IRepositoryBase  # noqa: F401
+from .model_base import BaseModel  # noqa: F401  # COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler

ormlambda/common/__init__.py

@@ -1,2 +1 @@
 
-

ormlambda/common/abstract_classes/__init__.py

@@ -1,3 +1,3 @@
 from .non_query_base import NonQueryBase  # noqa: F401
 from .abstract_model import AbstractSQLStatements  # noqa: F401
-from .query_base import QueryBase  # noqa: F401
+from .query_base import QueryBase  # noqa: F401

ormlambda/common/abstract_classes/abstract_model.py

@@ -1,21 +1,27 @@
-from typing import Any, Callable, Optional, Type, override, Iterable, Literal
+from __future__ import annotations
+from typing import Any, Callable, Optional, Type, override, Iterable, Literal, TYPE_CHECKING
 from enum import Enum
 from collections import defaultdict
 from abc import abstractmethod
 import inspect
 
-from ...utils import ForeignKey, Table
+from ormlambda.utils import ForeignKey, Table
 
-from ..interfaces import IQuery, IRepositoryBase, IStatements_two_generic
-from ..interfaces.IStatements import OrderType
+from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
 
-from ...components.update import UpdateQueryBase
-from ...components.select import ISelect
-from ...components.delete import DeleteQueryBase
-from ...components.upsert import UpsertQueryBase
-from ...components.select import TableColumn
-from ...components.insert import InsertQueryBase
-from ...components.where.abstract_where import AbstractWhere
+if TYPE_CHECKING:
+    from ormlambda.common.interfaces.IStatements import OrderType
+
+    from ormlambda.components.update import UpdateQueryBase
+    from ormlambda.components.select import ISelect
+    from ormlambda.components.delete import DeleteQueryBase
+    from ormlambda.components.upsert import UpsertQueryBase
+    from ormlambda.components.select import TableColumn
+    from ormlambda.components.insert import InsertQueryBase
+    from ormlambda.components.where.abstract_where import AbstractWhere
+
+    from ormlambda.databases.my_sql.clauses.select import SelectQuery
+    from ormlambda.databases.my_sql.clauses.count import CountQuery
 
 
 class JoinType(Enum):
@@ -82,7 +88,11 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
     def ORDER_QUERY(self) -> Type[IQuery]: ...
     @property
     @abstractmethod
-    def SELECT_QUERY(self) -> Type[ISelect]: ...
+    def SELECT_QUERY(self) -> Type[SelectQuery]: ...
+
+    @property
+    @abstractmethod
+    def COUNT(self) -> Type[CountQuery]: ...
 
     @override
     def create_table(self) -> None:
@@ -151,9 +161,16 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
         self._query_list["offset"].append(offset)
         return self
 
+    @override
+    def count(self) -> int:
+        count_select: IQuery = self.COUNT(self._model)
+        self._query_list["select"].append(count_select)
+        query = self.build()
+        return self.repository.read_sql(query)[0][0]
+
     @override
     def join(self, table_left: Table, table_right: Table, *, by: str) -> "IStatements_two_generic[T,TRepo]":
-        where = ForeignKey.MAPPED[table_left][table_right]
+        where = ForeignKey.MAPPED[table_left.__table_name__][table_right.__table_name__]
         join_query = self.JOIN_QUERY[table_left, Table](table_left, table_right, JoinType(by), where=where)
         self._query_list["join"].append(join_query)
         return self

ormlambda/common/abstract_classes/non_query_base.py

@@ -1,13 +1,15 @@
+from __future__ import annotations
 from abc import abstractmethod
-from typing import Any, Optional, override
+from typing import Any, Optional, Type, override, TYPE_CHECKING
 
-from ..interfaces.INonQueryCommand import INonQueryCommand
+from ormlambda.common.interfaces.INonQueryCommand import INonQueryCommand
 
-from ..interfaces import IRepositoryBase
-from ...utils import Table
+if TYPE_CHECKING:
+    from ormlambda import IRepositoryBase
+    from ormlambda import Table
 
 
-class NonQueryBase[T: Table, TRepo: IRepositoryBase](INonQueryCommand):
+class NonQueryBase[T: Type[Table], TRepo: IRepositoryBase](INonQueryCommand):
     __slots__: tuple[str, ...] = ("_model", "_repository", "_values", "_query")
 
     def __init__(self, model: T, repository: TRepo) -> None:

ormlambda/common/abstract_classes/query_base.py

@@ -1,7 +1,10 @@
 from abc import abstractmethod
+from typing import TYPE_CHECKING
 
-from ...utils import Table
-from ..interfaces import IQuery
+from ormlambda.common.interfaces import IQuery
+
+if TYPE_CHECKING:
+    from ormlambda import Table
 
 
 class QueryBase[T: Table](IQuery):

ormlambda/common/enums/__init__.py

@@ -1,2 +1,2 @@
 from .join_type import JoinType  # noqa: F401
-from .condition_types import ConditionType  # noqa: F401
+from .condition_types import ConditionType  # noqa: F401

ormlambda/common/enums/join_type.py

@@ -1,5 +1,6 @@
 from enum import Enum
 
+
 class JoinType(Enum):
     RIGHT_INCLUSIVE = "RIGHT JOIN"
     LEFT_INCLUSIVE = "LEFT JOIN"
@@ -7,4 +8,4 @@ class JoinType(Enum):
     LEFT_EXCLUSIVE = "LEFT JOIN"
     FULL_OUTER_INCLUSIVE = "RIGHT JOIN"
     FULL_OUTER_EXCLUSIVE = "RIGHT JOIN"
-    INNER_JOIN = "INNER JOIN"
+    INNER_JOIN = "INNER JOIN"

ormlambda/common/interfaces/IQueryCommand.py

@@ -2,7 +2,8 @@ from abc import abstractmethod, ABC
 
 
 class IQuery(ABC):
-    """ Interface to queries that retrieve any element such as select, limit, offset, where, group by, etc..."""
+    """Interface to queries that retrieve any element such as select, limit, offset, where, group by, etc..."""
+
     @property
     @abstractmethod
     def query(self) -> str: ...

ormlambda/common/interfaces/IStatements.py

@@ -1,10 +1,13 @@
-from typing import Any, Callable, Iterable, Optional, Literal, Type, overload
+from __future__ import annotations
+from typing import Any, Callable, Iterable, Optional, Literal, Type, overload, TYPE_CHECKING
 from enum import Enum
 from abc import abstractmethod, ABC
 
 from .IRepositoryBase import IRepositoryBase
-from ..enums import JoinType
-from ...utils import Table
+from ormlambda.common.enums import JoinType
+
+if TYPE_CHECKING:
+    from ormlambda import Table
 
 OrderType = Literal["ASC", "DESC"]
 
@@ -38,6 +41,8 @@ class IStatements[T: Table](ABC):
     @abstractmethod
     def insert(self, values: T | list[T]) -> None: ...
 
+    # endregion
+
     # region upsert
     @overload
     def upsert(self, values: T) -> None:
@@ -71,13 +76,19 @@ class IStatements[T: Table](ABC):
 
     # region limit
     @abstractmethod
-    def limit(self, number: int) -> "IStatements[T]": ...
+    def limit(self, number: int) -> IStatements[T]: ...
 
     # endregion
 
     # region offset
     @abstractmethod
-    def offset(self, number: int) -> "IStatements[T]": ...
+    def offset(self, number: int) -> IStatements[T]: ...
+
+    # endregion
+
+    # region count
+    @abstractmethod
+    def count(self) -> int: ...
 
     # endregion
 
@@ -97,13 +108,13 @@ class IStatements[T: Table](ABC):
 
     # region join
     @abstractmethod
-    def join(self, table_left: Table, table_right: Table, *, by: str) -> "IStatements[T]": ...
+    def join(self, table_left: Table, table_right: Table, *, by: str) -> IStatements[T]: ...
 
     # endregion
 
     # region where
     @overload
-    def where(self, lambda_: Callable[[T], bool]) -> "IStatements[T]":
+    def where(self, lambda_: Callable[[T], bool]) -> IStatements[T]:
         """
         This method creates where clause by passing the lambda's condition
 
@@ -115,7 +126,7 @@ class IStatements[T: Table](ABC):
         ...
 
     @overload
-    def where(self, lambda_: Callable[[T], Iterable]) -> "IStatements[T]":
+    def where(self, lambda_: Callable[[T], Iterable]) -> IStatements[T]:
         """
         This method creates where clause by passing the Iterable in lambda function
         EXAMPLE
@@ -126,7 +137,7 @@ class IStatements[T: Table](ABC):
         ...
 
     @overload
-    def where(self, lambda_: Callable[[T], bool], **kwargs) -> "IStatements[T]":
+    def where(self, lambda_: Callable[[T], bool], **kwargs) -> IStatements[T]:
         """
         PARAM
         -
@@ -143,17 +154,17 @@ class IStatements[T: Table](ABC):
         ...
 
     @abstractmethod
-    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> "IStatements[T]": ...
+    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> IStatements[T]: ...
 
     # endregion
 
     # region order
     @overload
-    def order[TValue](self, _lambda_col: Callable[[T], TValue]) -> "IStatements[T]": ...
+    def order[TValue](self, _lambda_col: Callable[[T], TValue]) -> IStatements[T]: ...
     @overload
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> "IStatements[T]": ...
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements[T]: ...
     @abstractmethod
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> "IStatements[T]": ...
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements[T]: ...
 
     # endregion
 
@@ -203,7 +214,7 @@ class IStatements[T: Table](ABC):
     @overload
     def select_one(self) -> T: ...
     @overload
-    def select_one(self, *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[tuple]) -> tuple: ...
+    def select_one[TFlavour](self, *, by: Optional[Enum] = JoinType.INNER_JOIN, flavour: Type[TFlavour]) -> TFlavour: ...
     @overload
     def select_one[T1](self, selector: Callable[[T], tuple[T1]], *, by: Optional[Enum] = JoinType.INNER_JOIN) -> T1: ...
     @overload

ormlambda/common/interfaces/__init__.py

@@ -1,4 +1,4 @@
 from .IQueryCommand import IQuery  # noqa: F401
 from .INonQueryCommand import INonQueryCommand  # noqa: F401
 from .IRepositoryBase import IRepositoryBase  # noqa: F401
-from .IStatements import IStatements,IStatements_two_generic  # noqa: F401
+from .IStatements import IStatements, IStatements_two_generic  # noqa: F401

ormlambda/components/delete/abstract_delete.py

@@ -1,9 +1,12 @@
+from __future__ import annotations
 from abc import abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda import Table, IRepositoryBase
+from ormlambda.common.abstract_classes import NonQueryBase
 
 from .IDelete import IDelete
-from ...utils import Table
-from ...common.interfaces import IRepositoryBase
-from ...common.abstract_classes import NonQueryBase
 
 
 class DeleteQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IDelete[T]):

ormlambda/components/insert/IInsert.py

@@ -3,4 +3,4 @@ from abc import ABC, abstractmethod
 
 class IInsert[T](ABC):
     @abstractmethod
-    def insert(self, instances: T | list[T])->None: ...
+    def insert(self, instances: T | list[T]) -> None: ...

ormlambda/components/insert/abstract_insert.py

@@ -1,12 +1,16 @@
+from __future__ import annotations
 from abc import abstractmethod
-from ...utils import Table
+from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from ormlambda import Table
+    from ormlambda import IRepositoryBase
+
+from ormlambda.common.abstract_classes import NonQueryBase
 from .IInsert import IInsert
-from ...common.interfaces import IRepositoryBase
-from ...common.abstract_classes import NonQueryBase
 
 
-class InsertQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, IRepositoryBase], IInsert[T]):
+class InsertQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IInsert[T]):
     def __init__(self, model: T, repository: TRepo) -> None:
         super().__init__(model, repository)
 

ormlambda/components/select/ISelect.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 
-from ...common.interfaces import IQuery
+from ormlambda.common.interfaces import IQuery
 from .table_column import TableColumn
 
 

ormlambda/components/select/table_column.py

@@ -1,5 +1,9 @@
+from __future__ import annotations
 from typing import Any, Iterator
-from ...utils import Table
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda import Table
 
 
 class TableColumn:

ormlambda/components/update/IUpdate.py

@@ -4,4 +4,4 @@ from typing import Any
 
 class IUpdate(ABC):
     @abstractmethod
-    def update(self, dicc: dict[str|property, Any]) -> None: ...
+    def update(self, dicc: dict[str | property, Any]) -> None: ...

ormlambda/components/update/__init__.py

@@ -1,2 +1,2 @@
 from .abstract_update import UpdateQueryBase  # noqa: F401
-from .IUpdate import IUpdate  # noqa: F401
+from .IUpdate import IUpdate  # noqa: F401

ormlambda/components/update/abstract_update.py

@@ -1,11 +1,15 @@
+from __future__ import annotations
 from abc import abstractmethod
-from typing import Any, Optional
+from typing import Any, Optional, TYPE_CHECKING
+
+from ormlambda.components.where import AbstractWhere
+from ormlambda.common.abstract_classes import NonQueryBase
+
+if TYPE_CHECKING:
+    from ormlambda import IRepositoryBase
+    from ormlambda import Table
 
 from .IUpdate import IUpdate
-from ..where import AbstractWhere
-from ...common.interfaces import IRepositoryBase
-from ...common.abstract_classes import NonQueryBase
-from ...utils import Table
 
 
 class UpdateQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IUpdate):

ormlambda/components/upsert/__init__.py

@@ -1,2 +1,2 @@
 from .abstract_upsert import UpsertQueryBase  # noqa: F401
-from .IUpsert import IUpsert  # noqa: F401
+from .IUpsert import IUpsert  # noqa: F401

ormlambda/components/upsert/abstract_upsert.py

@@ -1,9 +1,13 @@
+from __future__ import annotations
 from abc import abstractmethod
-from .IUpsert import IUpsert
-from ...common.interfaces import IRepositoryBase
-from ...common.abstract_classes import NonQueryBase
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda import IRepositoryBase
+    from ormlambda import Table
 
-from ...utils import Table
+from ormlambda.common.abstract_classes import NonQueryBase
+from .IUpsert import IUpsert
 
 
 class UpsertQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IUpsert[T]):

ormlambda/components/where/abstract_where.py

@@ -1,7 +1,11 @@
+from __future__ import annotations
 from abc import abstractmethod
-from ...utils import Table
+from typing import TYPE_CHECKING
 
-from ...common.interfaces import IQuery
+if TYPE_CHECKING:
+    from ormlambda import Table
+
+from ormlambda.common.interfaces import IQuery
 
 
 class AbstractWhere(IQuery):

ormlambda/databases/my_sql/clauses/__init__.py

@@ -11,3 +11,4 @@ from .select import SelectQuery  # noqa: F401
 from .update import UpdateQuery  # noqa: F401
 from .upsert import UpsertQuery  # noqa: F401
 from .where_condition import WhereCondition  # noqa: F401
+from .count import CountQuery  # noqa: F401

ormlambda/databases/my_sql/clauses/count.py

@@ -0,0 +1,35 @@
+from typing import Callable, Type, override
+
+from ormlambda import Table, JoinType, ForeignKey
+from ormlambda.databases.my_sql.clauses.joins import JoinSelector
+from ormlambda.databases.my_sql.clauses.select import SelectQuery
+
+
+class CountQuery[T: Type[Table]](SelectQuery[T]):
+    CLAUSE: str = "COUNT"
+
+    def __init__(
+        self,
+        tables: T | tuple[T] = (),
+        select_lambda: Callable[[T], None] | None = lambda: None,
+        *,
+        by: JoinType = JoinType.INNER_JOIN,
+    ) -> None:
+        super().__init__(tables, select_lambda, by=by)
+
+    @override
+    @property
+    def query(self) -> str:
+        query: str = f"{self.SELECT} {self.CLAUSE}(*) FROM {self._first_table.__table_name__}"
+
+        involved_tables = self.get_involved_tables()
+        if not involved_tables:
+            return query
+
+        sub_query: str = ""
+        for l_tbl, r_tbl in involved_tables:
+            join = JoinSelector(l_tbl, r_tbl, by=self._by, where=ForeignKey.MAPPED[l_tbl.__table_name__].referenced_tables[r_tbl.__table_name__].relationship)
+            sub_query += f" {join.query}"
+
+        query += sub_query
+        return query

ormlambda/databases/my_sql/clauses/create_database.py

@@ -1,8 +1,8 @@
 from typing import Literal, override
-from mysql.connector import Error, errorcode
+from mysql.connector import errorcode, errors
 from mysql.connector import MySQLConnection
 
-from ....common.interfaces import IRepositoryBase
+from ormlambda import IRepositoryBase
 
 TypeExists = Literal["fail", "replace", "append"]
 
@@ -18,12 +18,19 @@ class CreateDatabase:
 
     @override
     def execute(self, name: str, if_exists: TypeExists = "fail") -> None:
-        with self._repository.connection.cursor() as cursor:
-            try:
-                cursor.execute(f"{self.CLAUSE} {name} DEFAULT CHARACTER SET 'utf8'")
-            except Error as err:
-                if err.errno == errorcode.ER_DB_CREATE_EXISTS and if_exists != "fail":
-                    cursor.execute(f"USE {name};")
-                else:
-                    raise err
+        if self._repository.database_exists(name):
+            if if_exists == "replace":
+                self._repository.drop_database(name)
+            elif if_exists == "fail":
+                raise errors.DatabaseError(msg=f"Database '{name}' already exists", errno=errorcode.ER_DB_CREATE_EXISTS)
+            elif if_exists == "append":
+                counter: int = 0
+                char: str = ""
+                while self._repository.database_exists(name + char):
+                    counter += 1
+                    char = f"_{counter}"
+                name += char
+
+        query = f"{self.CLAUSE} {name} DEFAULT CHARACTER SET 'utf8'"
+        self._repository.execute(query)
         return None

ormlambda/databases/my_sql/clauses/delete.py

@@ -1,8 +1,11 @@
-from typing import Any, override, Iterable
+from typing import Any, override, Iterable, TYPE_CHECKING
 
-from ....utils import Table, Column
-from ....common.interfaces import IRepositoryBase
-from ....components.delete import DeleteQueryBase
+if TYPE_CHECKING:
+    from ormlambda import Column
+
+from ormlambda import Table
+from ormlambda import IRepositoryBase
+from ormlambda.components.delete import DeleteQueryBase
 from mysql.connector import MySQLConnection
 
 

ormlambda/databases/my_sql/clauses/drop_database.py

@@ -2,7 +2,7 @@ from typing import override
 from mysql.connector import MySQLConnection
 
 
-from ....common.interfaces import IRepositoryBase
+from ormlambda import IRepositoryBase
 
 
 class DropDatabase:

ormlambda/databases/my_sql/clauses/drop_table.py

@@ -1,6 +1,6 @@
 from typing import Literal, override
 
-from ....common.interfaces import IRepositoryBase
+from ormlambda import IRepositoryBase
 
 from mysql.connector import MySQLConnection
 

ormlambda/databases/my_sql/clauses/insert.py

@@ -1,9 +1,10 @@
 from typing import Any, override, Iterable
 from mysql.connector import MySQLConnection
 
-from ....utils import Table, Column
-from ....components.insert import InsertQueryBase
-from ....common.interfaces import IRepositoryBase
+from ormlambda import Table
+from ormlambda import Column
+from ormlambda.components.insert import InsertQueryBase
+from ormlambda import IRepositoryBase
 
 
 class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase[MySQLConnection]]):

ormlambda/databases/my_sql/clauses/joins.py

@@ -1,13 +1,14 @@
-from typing import override, Callable, overload, Optional, TypeVar
+from __future__ import annotations
+from typing import override, Callable, overload, Optional, TYPE_CHECKING
 
-# from ..table import Table
 
-from ....common.interfaces.IQueryCommand import IQuery
-from ....utils.lambda_disassembler import Disassembler
-from ....common.enums import JoinType
+from ormlambda.common.interfaces.IQueryCommand import IQuery
+from ormlambda import Disassembler
+from ormlambda import JoinType
 
-# TODOL: Try to import Table module without circular import Error
-Table = TypeVar("Table")
+# TODOL [x]: Try to import Table module without circular import Error
+if TYPE_CHECKING:
+    from ormlambda import Table
 
 
 class JoinSelector[TLeft, TRight](IQuery):

ormlambda/databases/my_sql/clauses/limit.py

@@ -1,6 +1,6 @@
 from typing import override
 
-from ....common.interfaces.IQueryCommand import IQuery
+from ormlambda.common.interfaces.IQueryCommand import IQuery
 
 
 class LimitQuery(IQuery):

ormlambda/databases/my_sql/clauses/offset.py

@@ -1,6 +1,6 @@
 from typing import override
 
-from ....common.interfaces.IQueryCommand import IQuery
+from ormlambda.common.interfaces.IQueryCommand import IQuery
 
 
 class OffsetQuery(IQuery):

ormlambda/databases/my_sql/clauses/order.py

@@ -1,8 +1,8 @@
 from typing import override, Callable
 
-from ....utils.lambda_disassembler.tree_instruction import TreeInstruction
-from ....common.interfaces.IQueryCommand import IQuery
-from ....common.interfaces.IStatements import OrderType
+from ormlambda.utils.lambda_disassembler.tree_instruction import TreeInstruction
+from ormlambda.common.interfaces.IQueryCommand import IQuery
+from ormlambda.common.interfaces.IStatements import OrderType
 
 ASC = "ASC"
 DESC = "DESC"

ormlambda/databases/my_sql/clauses/select.py

@@ -1,10 +1,10 @@
 from typing import Callable, Optional, Type, override
 import inspect
 
-from ....utils.lambda_disassembler import TreeInstruction, TupleInstruction, NestedElement
-from ....components.select import ISelect, TableColumn
-from ....utils import Table, ForeignKey
-from ....utils.table_constructor import TableMeta
+from ormlambda.utils.lambda_disassembler import TreeInstruction, TupleInstruction, NestedElement
+from ormlambda.components.select import ISelect, TableColumn
+from ormlambda import Table, ForeignKey
+from ormlambda.utils.table_constructor import TableMeta
 
 from . import JoinSelector, JoinType
 
@@ -152,7 +152,7 @@ class SelectQuery[T: Table, *Ts](ISelect):
 
         sub_query: str = ""
         for l_tbl, r_tbl in involved_tables:
-            join = JoinSelector(l_tbl, r_tbl, by=self._by, where=ForeignKey.MAPPED[l_tbl][r_tbl])
+            join = JoinSelector(l_tbl, r_tbl, by=self._by, where=ForeignKey.MAPPED[l_tbl.__table_name__].referenced_tables[r_tbl.__table_name__].relationship)
             sub_query += f" {join.query}"
 
         query += sub_query

ormlambda/databases/my_sql/clauses/update.py

@@ -1,9 +1,9 @@
 from typing import Type, override, Any
 from mysql.connector import MySQLConnection
 
-from ....components.update import UpdateQueryBase
-from ....utils import Table, Column
-from ....common.interfaces import IRepositoryBase
+from ormlambda.components.update import UpdateQueryBase
+from ormlambda import Table, Column
+from ormlambda import IRepositoryBase
 from .where_condition import WhereCondition