ormlambda 1.2.1__tar.gz → 1.3.0__tar.gz

{ormlambda-1.2.1 → ormlambda-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 1.2.1
+Version: 1.3.0
 Summary: ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions
 Author: p-hzamora
 Author-email: p.hzamora@icloud.com
@@ -8,7 +8,7 @@ Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: fluent-validation (>=3.1.0,<4.0.0)
-Requires-Dist: mysql-connector-python (>=2.2.9,<3.0.0)
+Requires-Dist: mysql-connector-python (>=9.0.0,<10.0.0)
 Description-Content-Type: text/markdown
 
 ![PyPI version](https://img.shields.io/pypi/v/ormlambda.svg)

{ormlambda-1.2.1 → ormlambda-1.3.0}/pyproject.toml

@@ -3,14 +3,14 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "1.2.1"
+version = "1.3.0"
 description = "ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions"
 authors = ["p-hzamora <p.hzamora@icloud.com>"]
 readme = "README.md"
 
 [tool.poetry.dependencies]
 python = "^3.12"
-mysql-connector-python= "^2.2.9"
+mysql-connector-python= "^9.0.0"
 fluent-validation = "^3.1.0"
 
 [tool.poetry.group.test.dependencies]

{ormlambda-1.2.1 → ormlambda-1.3.0}/src/ormlambda/__init__.py

@@ -4,6 +4,7 @@ from .common.enums import (  # noqa: F401
     ConditionType,
 )
 
+from .common.abstract_classes import AbstractSQLStatements  # noqa: F401
 from .common.interfaces import IRepositoryBase  # noqa: F401
 from .utils import Table, Column, ForeignKey  # noqa: F401
 from .utils.lambda_disassembler import Disassembler, nameof  # noqa: F401

ormlambda-1.3.0/src/ormlambda/common/abstract_classes/abstract_model.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+from typing import Any, Type, override, Iterable, Literal, TYPE_CHECKING
+from collections import defaultdict
+
+
+from ormlambda.utils import Table
+from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
+
+if TYPE_CHECKING:
+    from ormlambda.components.select import ISelect
+    from ormlambda.components.select import TableColumn
+
+
+ORDER_QUERIES = Literal["select", "join", "where", "order", "with", "group by", "limit", "offset"]
+
+
+class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
+    __slots__ = ("_model", "_repository", "_query_list")
+    __order__: tuple[str, ...] = ("select", "join", "where", "order", "with", "group by", "limit", "offset")
+
+    def __init__(self, model: T, repository: IRepositoryBase[TRepo]) -> None:
+        self.__valid_repository(repository)
+
+        self._model: T = model
+        self._repository: IRepositoryBase[TRepo] = repository
+        self._query_list: dict[ORDER_QUERIES, list[IQuery]] = defaultdict(list)
+
+        if not issubclass(self._model, Table):
+            # Deben heredar de Table ya que es la forma que tenemos para identificar si estamos pasando una instancia del tipo que corresponde o no cuando llamamos a insert o upsert.
+            # Si no heredase de Table no sabriamos identificar el tipo de dato del que se trata porque al llamar a isinstance, obtendriamos el nombre de la clase que mapea a la tabla, Encargo, Edificio, Presupuesto y no podriamos crear una clase generica
+            raise Exception(f"'{model}' class does not inherit from Table class")
+
+    @staticmethod
+    def __valid_repository(repository: Any) -> bool:
+        if not isinstance(repository, IRepositoryBase):
+            raise ValueError(f"'repository' attribute does not instance of '{IRepositoryBase.__name__}'")
+        return True
+
+    def __repr__(self):
+        return f"<Model: {self.__class__.__name__}>"
+
+    @property
+    @override
+    def repository(self) -> IRepositoryBase[TRepo]: ...
+
+    def _return_flavour[TValue](self, query, flavour: Type[TValue]) -> tuple[TValue]:
+        return self._repository.read_sql(query, flavour=flavour)
+
+    def _return_model(self, select: ISelect, query: str):
+        response_sql = self._repository.read_sql(query, flavour=dict)  # store all columns of the SQL query
+
+        if isinstance(response_sql, Iterable):
+            return ClusterQuery(select, response_sql).clean_response()
+
+        return response_sql
+
+
+class ClusterQuery:
+    def __init__(self, select: ISelect, response_sql: tuple[dict[str, Any]]) -> None:
+        self._select: ISelect = select
+        self._response_sql: tuple[dict[str, Any]] = response_sql
+
+    def loop_foo(self) -> dict[Type[Table], list[Table]]:
+        #  We must ensure to get the valid attributes for each instance
+        table_initialize = defaultdict(list)
+
+        unic_table: dict[Table, list[TableColumn]] = defaultdict(list)
+        for table_col in self._select.select_list:
+            unic_table[table_col._table].append(table_col)
+
+        for table_, table_col in unic_table.items():
+            for dicc_cols in self._response_sql:
+                valid_attr: dict[str, Any] = {}
+                for col in table_col:
+                    valid_attr[col.real_column] = dicc_cols[col.alias]
+                # COMMENT: At this point we are going to instantiate Table class with specific attributes getting directly from database
+                table_initialize[table_].append(table_(**valid_attr))
+        return table_initialize
+
+    def clean_response(self) -> tuple[dict[Type[Table], tuple[Table]]]:
+        tbl_dicc: dict[Type[Table], list[Table]] = self.loop_foo()
+
+        # it not depend of flavour attr
+        for key, val in tbl_dicc.items():
+            tbl_dicc[key] = tuple(val)
+
+        return tuple(tbl_dicc.values())

{ormlambda-1.2.1 → ormlambda-1.3.0}/src/ormlambda/common/interfaces/IRepositoryBase.py

@@ -25,7 +25,7 @@ class IRepositoryBase[T](ABC):
     def is_connected(self) -> bool: ...
 
     @abstractmethod
-    def connect(self, **kwargs: Any) -> "IRepositoryBase[T]": ...
+    def connect(self, **kwargs: Any) -> None: ...
 
     @abstractmethod
     def close_connection(self) -> None: ...

{ormlambda-1.2.1 → ormlambda-1.3.0}/src/ormlambda/databases/my_sql/repository.py

@@ -85,7 +85,7 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         return self._connection.is_connected()
 
     @override
-    def connect(self) -> IRepositoryBase[MySQLConnection]:
+    def connect(self) -> None:
         # return MySQLConnectionPool(pool_name="mypool", pool_size=5, **kwargs)
         self._connection.connect(**self._data_config)
         return None

ormlambda-1.2.1/src/ormlambda/common/abstract_classes/abstract_model.py → ormlambda-1.3.0/src/ormlambda/databases/my_sql/statements.py

@@ -1,98 +1,49 @@
 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 ormlambda.utils import ForeignKey, Table
-
-from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
+from typing import override, Type, TYPE_CHECKING, Any, Callable, Optional
 
 if TYPE_CHECKING:
-    from ormlambda.common.interfaces.IStatements import OrderType
-
-    from ormlambda.components.update import UpdateQueryBase
+    from ormlambda import Table
     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.common.interfaces.IStatements import OrderType
+    from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
+    
     from ormlambda.databases.my_sql.clauses.select import SelectQuery
     from ormlambda.databases.my_sql.clauses.count import CountQuery
 
 
-class JoinType(Enum):
-    RIGHT_INCLUSIVE = "RIGHT JOIN"
-    LEFT_INCLUSIVE = "LEFT JOIN"
-    RIGHT_EXCLUSIVE = "RIGHT JOIN"
-    LEFT_EXCLUSIVE = "LEFT JOIN"
-    FULL_OUTER_INCLUSIVE = "RIGHT JOIN"
-    FULL_OUTER_EXCLUSIVE = "RIGHT JOIN"
-    INNER_JOIN = "INNER JOIN"
-
+from ormlambda import AbstractSQLStatements
+from .clauses import DeleteQuery
+from .clauses import InsertQuery
+from .clauses import JoinSelector
+from .clauses import LimitQuery
+from .clauses import OffsetQuery
+from .clauses import OrderQuery
+from .clauses import SelectQuery
+from .clauses import UpsertQuery
+from .clauses import UpdateQuery
+from .clauses import WhereCondition
+from .clauses import CountQuery
 
-ORDER_QUERIES = Literal["select", "join", "where", "order", "with", "group by", "limit", "offset"]
+from mysql.connector import MySQLConnection
 
 
-class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
-    __slots__ = ("_model", "_repository", "_query_list")
-    __order__: tuple[str, ...] = ("select", "join", "where", "order", "with", "group by", "limit", "offset")
 
-    def __init__(self, model: T, repository: IRepositoryBase[TRepo]) -> None:
-        self.valid_repository(repository)
+import inspect
 
-        self._model: T = model
-        self._repository: IRepositoryBase[TRepo] = repository
-        self._query_list: dict[ORDER_QUERIES, list[IQuery]] = defaultdict(list)
+from ormlambda.utils import ForeignKey, Table
+from ormlambda.common.enums import JoinType
 
-        if not issubclass(self._model, Table):
-            # Deben heredar de Table ya que es la forma que tenemos para identificar si estamos pasando una instancia del tipo que corresponde o no cuando llamamos a insert o upsert.
-            # Si no heredase de Table no sabriamos identificar el tipo de dato del que se trata porque al llamar a isinstance, obtendriamos el nombre de la clase que mapea a la tabla, Encargo, Edificio, Presupuesto y no podriamos crear una clase generica
-            raise Exception(f"'{model}' class does not inherit from Table class")
 
-    @staticmethod
-    def valid_repository(repository: Any) -> bool:
-        if not isinstance(repository, IRepositoryBase):
-            raise ValueError(f"'repository' attribute does not instance of '{IRepositoryBase.__name__}'")
-        return True
 
-    @property
-    @abstractmethod
-    def INSERT_QUERY(self) -> Type[InsertQueryBase[T, TRepo]]: ...
-    @property
-    @abstractmethod
-    def UPSERT_QUERY(self) -> Type[UpsertQueryBase[T, TRepo]]: ...
-    @property
-    @abstractmethod
-    def UPDATE_QUERY(self) -> Type[UpdateQueryBase[T, TRepo]]: ...
-    @property
-    @abstractmethod
-    def DELETE_QUERY(self) -> Type[DeleteQueryBase[T, TRepo]]: ...
-    @property
-    @abstractmethod
-    def LIMIT_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def OFFSET_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def JOIN_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def WHERE_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def ORDER_QUERY(self) -> Type[IQuery]: ...
-    @property
-    @abstractmethod
-    def SELECT_QUERY(self) -> Type[SelectQuery]: ...
+class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
+    def __init__(self, model: T, repository: IRepositoryBase[MySQLConnection]) -> None:
+        super().__init__(model, repository=repository)
 
     @property
-    @abstractmethod
-    def COUNT(self) -> Type[CountQuery]: ...
+    @override
+    def repository(self) -> IRepositoryBase[MySQLConnection]:
+        return self._repository
 
     @override
     def create_table(self) -> None:
@@ -106,7 +57,7 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
 
     @override
     def insert(self, instances: T | list[T]) -> None:
-        insert = self.INSERT_QUERY(self._model, self._repository)
+        insert = InsertQuery(self._model, self._repository)
         insert.insert(instances)
         insert.execute()
         self._query_list.clear()
@@ -122,7 +73,7 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
             # We always going to have a tuple of one element
             return self.delete(response)
 
-        delete = self.DELETE_QUERY(self._model, self._repository)
+        delete = DeleteQuery(self._model, self._repository)
         delete.delete(instances)
         delete.execute()
         # not necessary to call self._query_list.clear() because select() method already call it
@@ -130,7 +81,7 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
 
     @override
     def upsert(self, instances: T | list[T]) -> None:
-        upsert = self.UPSERT_QUERY(self._model, self._repository)
+        upsert = UpsertQuery(self._model, self._repository)
         upsert.upsert(instances)
         upsert.execute()
         self._query_list.clear()
@@ -138,15 +89,15 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
 
     @override
     def update(self, dicc: dict[str, Any] | list[dict[str, Any]]) -> None:
-        update = self.UPDATE_QUERY(self._model, self._repository, self._query_list["where"])
+        update = UpdateQuery(self._model, self._repository, self._query_list["where"])
         update.update(dicc)
         update.execute()
         self._query_list.clear()
         return None
 
     @override
-    def limit(self, number: int) -> "IStatements_two_generic[T,TRepo]":
-        limit = self.LIMIT_QUERY(number)
+    def limit(self, number: int) -> IStatements_two_generic[T, MySQLConnection]:
+        limit = LimitQuery(number)
         # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
         limit_list = self._query_list["limit"]
         if len(limit_list) > 0:
@@ -156,35 +107,35 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
         return self
 
     @override
-    def offset(self, number: int) -> "IStatements_two_generic[T,TRepo]":
-        offset = self.OFFSET_QUERY(number)
+    def offset(self, number: int) -> IStatements_two_generic[T, MySQLConnection]:
+        offset = OffsetQuery(number)
         self._query_list["offset"].append(offset)
         return self
 
     @override
     def count(self) -> int:
-        count_select: IQuery = self.COUNT(self._model)
+        count_select: IQuery = CountQuery(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]":
+    def join(self, table_left: Table, table_right: Table, *, by: str) -> IStatements_two_generic[T, MySQLConnection]:
         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)
+        join_query = JoinSelector[table_left, Table](table_left, table_right, JoinType(by), where=where)
         self._query_list["join"].append(join_query)
         return self
 
     @override
-    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> "IStatements_two_generic[T,TRepo]":
+    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> IStatements_two_generic[T, MySQLConnection]:
         # FIXME [x]: I've wrapped self._model into tuple to pass it instance attr. Idk if it's correct
-        where_query = self.WHERE_QUERY[T](function=lambda_, instances=(self._model,), **kwargs)
+        where_query = WhereCondition[T](function=lambda_, instances=(self._model,), **kwargs)
         self._query_list["where"].append(where_query)
         return self
 
     @override
-    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> "IStatements_two_generic[T,TRepo]":
-        order = self.ORDER_QUERY[T](self._model, _lambda_col, order_type)
+    def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements_two_generic[T, MySQLConnection]:
+        order = OrderQuery[T](self._model, _lambda_col, order_type)
         self._query_list["order"].append(order)
         return self
 
@@ -198,7 +149,7 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
             if flavour:
                 return result
             return () if not result else result[0]
-        select: ISelect = self.SELECT_QUERY(self._model, select_lambda=selector, by=by)
+        select: ISelect = SelectQuery(self._model, select_lambda=selector, by=by)
         self._query_list["select"].append(select)
 
         query: str = self.build()
@@ -209,17 +160,6 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
             return result
         return self._return_model(select, query)
 
-    def _return_flavour[TValue](self, query, flavour: Type[TValue]) -> tuple[TValue]:
-        return self._repository.read_sql(query, flavour=flavour)
-
-    def _return_model(self, select: ISelect, query: str):
-        response_sql = self._repository.read_sql(query, flavour=dict)  # store all columns of the SQL query
-
-        if isinstance(response_sql, Iterable):
-            return ClusterQuery(select, response_sql).clean_response()
-
-        return response_sql
-
     @override
     def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
         self.limit(1)
@@ -241,14 +181,14 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
     def build(self) -> str:
         query: str = ""
 
-        self._create_necessary_inner_join()
+        self.__create_necessary_inner_join()
         for x in self.__order__:
             if sub_query := self._query_list.get(x, None):
-                if isinstance(sub_query[0], self.WHERE_QUERY):
+                if isinstance(sub_query[0], WhereCondition):
                     query_ = self.__build_where_clause(sub_query)
 
                 # we must check if any join already exists on query string
-                elif isinstance(sub_query[0], self.JOIN_QUERY):
+                elif isinstance(sub_query[0], JoinSelector):
                     select_query: str = self._query_list["select"][0].query
                     query_ = ""
                     for join in sub_query:
@@ -270,7 +210,7 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
             query += f" {and_} ({clause})"
         return query
 
-    def _create_necessary_inner_join(self) -> None:
+    def __create_necessary_inner_join(self) -> None:
         # When we applied filters in any table that we wont select any column, we need to add manually all neccessary joins to achieve positive result.
         if "where" not in self._query_list:
             return None
@@ -285,35 +225,3 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
         for l_tbl, r_tbl in involved_tables:
             # FIXME [ ]: Checked what function was called by the self.join method before the change
             self.join(l_tbl, r_tbl, by="INNER JOIN")
-
-
-class ClusterQuery:
-    def __init__(self, select: ISelect, response_sql: tuple[dict[str, Any]]) -> None:
-        self._select: ISelect = select
-        self._response_sql: tuple[dict[str, Any]] = response_sql
-
-    def loop_foo(self) -> dict[Type[Table], list[Table]]:
-        #  We must ensure to get the valid attributes for each instance
-        table_initialize = defaultdict(list)
-
-        unic_table: dict[Table, list[TableColumn]] = defaultdict(list)
-        for table_col in self._select.select_list:
-            unic_table[table_col._table].append(table_col)
-
-        for table_, table_col in unic_table.items():
-            for dicc_cols in self._response_sql:
-                valid_attr: dict[str, Any] = {}
-                for col in table_col:
-                    valid_attr[col.real_column] = dicc_cols[col.alias]
-                # COMMENT: At this point we are going to instantiate Table class with specific attributes getting directly from database
-                table_initialize[table_].append(table_(**valid_attr))
-        return table_initialize
-
-    def clean_response(self) -> tuple[dict[Type[Table], tuple[Table]]]:
-        tbl_dicc: dict[Type[Table], list[Table]] = self.loop_foo()
-
-        # it not depend of flavour attr
-        for key, val in tbl_dicc.items():
-            tbl_dicc[key] = tuple(val)
-
-        return tuple(tbl_dicc.values())

{ormlambda-1.2.1 → ormlambda-1.3.0}/src/ormlambda/model_base.py

@@ -10,7 +10,7 @@ from .databases.my_sql import MySQLStatements, MySQLRepository
 # endregion
 
 
-class BaseModel[T: Table]:
+class BaseModel[T: Type[Table]]:
     """
     Class to select the correct AbstractSQLStatements class depends on the repository.
 
@@ -27,7 +27,7 @@ class BaseModel[T: Table]:
         cls: AbstractSQLStatements[T, TRepo] = cls.statements_dicc.get(type(repository), None)
 
         if not cls:
-            raise Exception(f"Repository selected does not exits '{repository}'")
+            raise Exception(f"The selected repository '{repository}' does not exist.")
 
         self = object().__new__(cls)
         cls.__init__(self, model, repository)

ormlambda-1.2.1/src/ormlambda/databases/my_sql/statements.py

@@ -1,95 +0,0 @@
-from __future__ import annotations
-from typing import override, Type, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ormlambda import Table
-    from ormlambda.components.select import ISelect
-
-from ormlambda.common.abstract_classes import AbstractSQLStatements
-
-from ormlambda.common.interfaces import IQuery, IRepositoryBase
-
-from .clauses import DeleteQuery
-from .clauses import InsertQuery
-from .clauses import JoinSelector
-from .clauses import LimitQuery
-from .clauses import OffsetQuery
-from .clauses import OrderQuery
-from .clauses import SelectQuery
-from .clauses import UpsertQuery
-from .clauses import UpdateQuery
-from .clauses import WhereCondition
-from .clauses import CountQuery
-
-from mysql.connector import MySQLConnection
-
-
-class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
-    def __init__(self, model: T, repository: IRepositoryBase[MySQLConnection]) -> None:
-        super().__init__(model, repository=repository)
-
-    # region Private methods
-    def __repr__(self):
-        return f"<Model: {self.__class__.__name__}>"
-
-    # endregion
-
-    @property
-    @override
-    def INSERT_QUERY(self) -> Type[InsertQuery]:
-        return InsertQuery
-
-    @property
-    @override
-    def UPSERT_QUERY(self) -> Type[UpsertQuery]:
-        return UpsertQuery
-
-    @property
-    @override
-    def UPDATE_QUERY(self) -> Type[UpsertQuery]:
-        return UpdateQuery
-
-    @override
-    @property
-    def DELETE_QUERY(self) -> Type[DeleteQuery]:
-        return DeleteQuery
-
-    @property
-    @override
-    def LIMIT_QUERY(self) -> Type[IQuery]:
-        return LimitQuery
-
-    @property
-    @override
-    def OFFSET_QUERY(self) -> Type[IQuery]:
-        return OffsetQuery
-
-    @property
-    @override
-    def COUNT(self) -> int:
-        return CountQuery
-
-    @property
-    @override
-    def JOIN_QUERY(self) -> Type[IQuery]:
-        return JoinSelector
-
-    @property
-    @override
-    def WHERE_QUERY(self) -> Type[IQuery]:
-        return WhereCondition
-
-    @property
-    @override
-    def ORDER_QUERY(self) -> Type[IQuery]:
-        return OrderQuery
-
-    @property
-    @override
-    def SELECT_QUERY(self) -> Type[ISelect]:
-        return SelectQuery
-
-    @property
-    @override
-    def repository(self) -> IRepositoryBase[MySQLConnection]:
-        return self._repository