ormlambda 3.7.2__tar.gz → 3.11.0__tar.gz

{ormlambda-3.7.2 → ormlambda-3.11.0}/PKG-INFO

@@ -1,15 +1,13 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 3.7.2
+Version: 3.11.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
 Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: fluent-validation (==4.3.1)
 Requires-Dist: mysql-connector-python (>=9.0.0,<10.0.0)
-Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: shapely (>=2.0.6,<3.0.0)
 Description-Content-Type: text/markdown
 
@@ -17,7 +15,7 @@ Description-Content-Type: text/markdown
 ![downloads](https://img.shields.io/pypi/dm/ormlambda?label=downloads)
 ![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)
 
-# ormMySQL
+# ormlambda Documentation
 This ORM is designed to connect with a MySQL server, facilitating the management of various database queries. Built with flexibility and efficiency in mind, this ORM empowers developers to interact with the database using lambda functions, allowing for concise and expressive query construction. 
 
 # Creating your first lambda query
@@ -38,19 +36,34 @@ database = MySQLRepository(user=USERNAME, password=PASSWORD, database="sakila",
 ## Select all columns
 ```python
 from ormlambda import ORM
-from ormlambda.databases.my_sql import MySQLRepository
+from ormlambda import create_engine
 
 from models.address import Address
-from config import config_dict
+from test.config import config_dict
 
-db = MySQLRepository(**config_dict)
+db = create_engine('mysql://root:1234@localhost:3306/sakila')
 
-AddressModel = ORM(Address,db)
+AddressModel = ORM(Address, db)
 
 result = AddressModel.select()
 ```
 The `result` var will be of type `tuple[Address, ...]` 
 
+## Improving Typing
+For those cases where you need to pass the database configuration from a `dict`, you can use `MySQLArgs` TypedDict object to improve type annotations.
+
+```python
+from ormlambda.databases.my_sql.types import MySQLArgs
+
+config_dict: MySQLArgs = {
+    "user": DB_USERNAME,
+    "password": DB_PASSWORD,
+    "host": DB_HOST,
+    "database": DB_DATABASE,
+}
+db = MySQLRepository(**config_dict)
+```
+
 ## Select multiples tables
 Once the `AddressModel` class is created, we will not only be able to access all the information in that table, but also all the information in all the tables that have foreign keys related to it."
 
@@ -296,6 +309,92 @@ res = AddressModel.sum(Address.address_id, execute=True)
 res = AddressModel.count(Address.address_id, execute=True)
 ```
 
+## 1. Concat
+
+The `concat` method allows you to concatenate multiple columns or values into a single string. This is particularly useful for creating derived fields in your queries.
+
+#### Usage
+
+```python
+response = ORM(Address, db).where(Address.City.Country.country.regex(r"^Spain")).first(
+            (
+                Address.address,
+                Address.City.city,
+                self.tmodel.concat(
+                    (
+                        "Address: ",
+                        Address.address,
+                        " - city: ",
+                        Address.City.city,
+                        " - country: ",
+                        Address.City.Country.country,
+                    )
+                ),
+            ),
+            flavour=dict,
+        )
+
+{
+    "address_address": "939 Probolinggo Loop",
+    "city_city": "A Coruña (La Coruña)",
+    "CONCAT": "Address: 939 Probolinggo Loop - city: A Coruña (La Coruña) - country: Spain",
+}
+```
+As you can see in the response, the result is a dictionary where the keys are a combination of the table name and the column name. This is done to avoid collisions with columns from other tables that might have the same name.
+
+Another elegant approach to adjust the response and obtain an object is by using the `flavour` attribute. You can pass a callable object, which will be used to instantiate it with the returned data.
+
+## Using BaseModel for Custom Responses (Pydantic)
+
+You can utilize `BaseModel` from Pydantic to create structured response models. This allows you to define the expected structure of your data, ensuring type safety and validation.
+
+### Example: Creating a Custom Response Model
+
+You can create a custom response model by subclassing `BaseModel`. In this model, you define the fields that you expect in your response, along with their types.
+
+```python
+class AddressCombine(BaseModel):
+    address: str
+    city: str
+    country: str
+
+    model_config: ConfigDict = {"extra": "forbid"}
+
+ddbb = MySQLRepository(**config_dict)
+model = ORM(Address, ddbb)
+select = (
+    model.order(lambda x: x.City.Country.country, "DESC")
+    .limit(10)
+    .where(Address.City.Country.country == "Spain")
+    .first(
+        lambda x: (
+            x.address,
+            x.City.city,
+            x.City.Country.country,
+        ),
+        flavour=AddressCombine,
+    )
+)
+```
+
+Once you execute the query, the result will be an instance of your custom model. You can access the fields directly, ensuring that the data adheres to the structure you defined.
+
+```python
+
+
+print(select.address)
+print(select.city)
+print(select.country)
+```
+
+
+<!-- ### 2. Having
+
+The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
+
+#### Usage -->
+
+
 ## Combine aggregation method
 As shown in the previous examples, setting the `execute` attribute to `True` allows us to perform the corresponding query in a single line. However, if you're looking to improve efficiency, you can combine all of them into one query.
 ```python

{ormlambda-3.7.2 → ormlambda-3.11.0}/README.md

@@ -2,7 +2,7 @@
 ![downloads](https://img.shields.io/pypi/dm/ormlambda?label=downloads)
 ![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)
 
-# ormMySQL
+# ormlambda Documentation
 This ORM is designed to connect with a MySQL server, facilitating the management of various database queries. Built with flexibility and efficiency in mind, this ORM empowers developers to interact with the database using lambda functions, allowing for concise and expressive query construction. 
 
 # Creating your first lambda query
@@ -23,19 +23,34 @@ database = MySQLRepository(user=USERNAME, password=PASSWORD, database="sakila",
 ## Select all columns
 ```python
 from ormlambda import ORM
-from ormlambda.databases.my_sql import MySQLRepository
+from ormlambda import create_engine
 
 from models.address import Address
-from config import config_dict
+from test.config import config_dict
 
-db = MySQLRepository(**config_dict)
+db = create_engine('mysql://root:1234@localhost:3306/sakila')
 
-AddressModel = ORM(Address,db)
+AddressModel = ORM(Address, db)
 
 result = AddressModel.select()
 ```
 The `result` var will be of type `tuple[Address, ...]` 
 
+## Improving Typing
+For those cases where you need to pass the database configuration from a `dict`, you can use `MySQLArgs` TypedDict object to improve type annotations.
+
+```python
+from ormlambda.databases.my_sql.types import MySQLArgs
+
+config_dict: MySQLArgs = {
+    "user": DB_USERNAME,
+    "password": DB_PASSWORD,
+    "host": DB_HOST,
+    "database": DB_DATABASE,
+}
+db = MySQLRepository(**config_dict)
+```
+
 ## Select multiples tables
 Once the `AddressModel` class is created, we will not only be able to access all the information in that table, but also all the information in all the tables that have foreign keys related to it."
 
@@ -281,6 +296,92 @@ res = AddressModel.sum(Address.address_id, execute=True)
 res = AddressModel.count(Address.address_id, execute=True)
 ```
 
+## 1. Concat
+
+The `concat` method allows you to concatenate multiple columns or values into a single string. This is particularly useful for creating derived fields in your queries.
+
+#### Usage
+
+```python
+response = ORM(Address, db).where(Address.City.Country.country.regex(r"^Spain")).first(
+            (
+                Address.address,
+                Address.City.city,
+                self.tmodel.concat(
+                    (
+                        "Address: ",
+                        Address.address,
+                        " - city: ",
+                        Address.City.city,
+                        " - country: ",
+                        Address.City.Country.country,
+                    )
+                ),
+            ),
+            flavour=dict,
+        )
+
+{
+    "address_address": "939 Probolinggo Loop",
+    "city_city": "A Coruña (La Coruña)",
+    "CONCAT": "Address: 939 Probolinggo Loop - city: A Coruña (La Coruña) - country: Spain",
+}
+```
+As you can see in the response, the result is a dictionary where the keys are a combination of the table name and the column name. This is done to avoid collisions with columns from other tables that might have the same name.
+
+Another elegant approach to adjust the response and obtain an object is by using the `flavour` attribute. You can pass a callable object, which will be used to instantiate it with the returned data.
+
+## Using BaseModel for Custom Responses (Pydantic)
+
+You can utilize `BaseModel` from Pydantic to create structured response models. This allows you to define the expected structure of your data, ensuring type safety and validation.
+
+### Example: Creating a Custom Response Model
+
+You can create a custom response model by subclassing `BaseModel`. In this model, you define the fields that you expect in your response, along with their types.
+
+```python
+class AddressCombine(BaseModel):
+    address: str
+    city: str
+    country: str
+
+    model_config: ConfigDict = {"extra": "forbid"}
+
+ddbb = MySQLRepository(**config_dict)
+model = ORM(Address, ddbb)
+select = (
+    model.order(lambda x: x.City.Country.country, "DESC")
+    .limit(10)
+    .where(Address.City.Country.country == "Spain")
+    .first(
+        lambda x: (
+            x.address,
+            x.City.city,
+            x.City.Country.country,
+        ),
+        flavour=AddressCombine,
+    )
+)
+```
+
+Once you execute the query, the result will be an instance of your custom model. You can access the fields directly, ensuring that the data adheres to the structure you defined.
+
+```python
+
+
+print(select.address)
+print(select.city)
+print(select.country)
+```
+
+
+<!-- ### 2. Having
+
+The `having` method is used to filter results based on aggregate functions. It is typically used in conjunction with `group by` clauses.
+
+#### Usage -->
+
+
 ## Combine aggregation method
 As shown in the previous examples, setting the `execute` attribute to `True` allows us to perform the corresponding query in a single line. However, if you're looking to improve efficiency, you can combine all of them into one query.
 ```python

{ormlambda-3.7.2 → ormlambda-3.11.0}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.7.2"
+version = "3.11.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"
@@ -11,11 +11,11 @@ readme = "README.md"
 [tool.poetry.dependencies]
 python = "^3.12"
 mysql-connector-python= "^9.0.0"
-fluent-validation = "4.3.1"
 shapely = "^2.0.6"
-python-dotenv = "^1.0.1"
 
 [tool.poetry.group.test.dependencies]
+fluent-validation = "4.3.1"
+python-dotenv = "^1.0.1"
 pandas = "^2.2.2"
 ruff = "^0.4.5"
 parameterized = "^0.9.0"

{ormlambda-3.7.2 → ormlambda-3.11.0}/src/ormlambda/__init__.py

@@ -20,3 +20,5 @@ from .model.base_model import (
     BaseModel as BaseModel,
     ORM as ORM,
 )  # COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler
+
+from .engine import create_engine, URL  # noqa: F401

{ormlambda-3.7.2 → ormlambda-3.11.0}/src/ormlambda/databases/my_sql/caster/caster.py

@@ -23,6 +23,7 @@ class MySQLCaster(ICaster):
             NoneType: NoneTypeCaster,
             datetime: DatetimeCaster,
             bytes: BytesCaster,
+            bytearray: BytesCaster,
             tuple: IterableCaster,
             list: IterableCaster,
         }

{ormlambda-3.7.2 → ormlambda-3.11.0}/src/ormlambda/databases/my_sql/clauses/__init__.py

@@ -12,6 +12,7 @@ from .order import Order as Order
 from .update import UpdateQuery as UpdateQuery
 from .upsert import UpsertQuery as UpsertQuery
 from .where import Where as Where
+from .having import Having as Having
 from .count import Count as Count
 from .group_by import GroupBy as GroupBy
 from .alias import Alias as Alias

ormlambda-3.11.0/src/ormlambda/databases/my_sql/clauses/alias.py

@@ -0,0 +1,28 @@
+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
+
+if tp.TYPE_CHECKING:
+    from ormlambda.sql.types import ColumnType
+    from ormlambda import Table
+    from ormlambda.sql.types import AliasType
+
+
+class Alias[T: Table](ClauseInfo[T]):
+    def __init__[TProp](
+        self,
+        table: TableType[T],
+        column: tp.Optional[ColumnType[TProp]] = None,
+        alias_table: tp.Optional[AliasType[ClauseInfo[T]]] = None,
+        alias_clause: tp.Optional[AliasType[ClauseInfo[T]]] = None,
+        context: ClauseContextType = None,
+        keep_asterisk: bool = False,
+        preserve_context: bool = False,
+    ):
+        if not alias_clause:
+            raise TypeError
+        super().__init__(table, column, alias_table, alias_clause, context, keep_asterisk, preserve_context)

ormlambda-3.11.0/src/ormlambda/databases/my_sql/clauses/group_by.py

@@ -0,0 +1,31 @@
+import typing as tp
+from ormlambda import Table
+from ormlambda.sql.clause_info.clause_info import AggregateFunctionBase
+from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
+from ormlambda.sql.types import ColumnType
+
+
+class GroupBy[T: tp.Type[Table], *Ts, TProp](AggregateFunctionBase):
+    @classmethod
+    def FUNCTION_NAME(self) -> str:
+        return "GROUP BY"
+
+    def __init__(
+        self,
+        column: ColumnType,
+        context: ClauseInfoContext,
+        **kwargs,
+    ):
+        super().__init__(
+            table=column.table,
+            column=column,
+            alias_table=None,
+            alias_clause=None,
+            context=context,
+            **kwargs,
+        )
+
+    @property
+    def query(self) -> str:
+        column = self._create_query()
+        return f"{self.FUNCTION_NAME()} {column}"

ormlambda-3.11.0/src/ormlambda/databases/my_sql/clauses/having.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .where import Where
+
+
+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)
+
+    @staticmethod
+    def FUNCTION_NAME() -> str:
+        return "HAVING"

{ormlambda-3.7.2 → ormlambda-3.11.0}/src/ormlambda/databases/my_sql/clauses/order.py

@@ -48,13 +48,18 @@ class Order(AggregateFunctionBase):
         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} {self._order_type[index].value}")
+            string_columns.append(f"{clause.query} {str(self._order_type[index])}")
 
         return f"{self.FUNCTION_NAME()} {', '.join(string_columns)}"

{ormlambda-3.7.2 → ormlambda-3.11.0}/src/ormlambda/databases/my_sql/clauses/where.py

@@ -32,8 +32,8 @@ class Where(AggregateFunctionBase):
     def alias_clause(self) -> None:
         return None
 
-    @staticmethod
-    def join_condition(wheres: tp.Iterable[Where], restrictive: bool, context: ClauseInfoContext) -> str:
+    @classmethod
+    def join_condition(cls, wheres: tp.Iterable[Where], restrictive: bool, context: ClauseInfoContext) -> str:
         if not isinstance(wheres, tp.Iterable):
             wheres = (wheres,)
 
@@ -42,4 +42,4 @@ class Where(AggregateFunctionBase):
             for c in where._comparer:
                 c.set_context(context)
                 comparers.append(c)
-        return Where(*comparers, restrictive=restrictive, context=context).query
+        return cls(*comparers, restrictive=restrictive, context=context).query

{ormlambda-3.7.2 → ormlambda-3.11.0}/src/ormlambda/databases/my_sql/functions/concat.py

@@ -1,20 +1,22 @@
+import typing as tp
+
 from ormlambda.sql.clause_info import AggregateFunctionBase
 from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
-
-
-import typing as tp
 from ormlambda.sql.types import ColumnType, AliasType
 from ormlambda.sql.clause_info import ClauseInfo
 
 
-class Concat[*Ts](AggregateFunctionBase):
+type ConcatResponse[TProp] = tuple[str | ColumnType[TProp]]
+
+
+class Concat[T](AggregateFunctionBase):
     @staticmethod
     def FUNCTION_NAME() -> str:
         return "CONCAT"
 
     def __init__[TProp](
         self,
-        values: ColumnType[Ts] | tuple[ColumnType[Ts], ...],
+        values: ConcatResponse[TProp],
         alias_clause: AliasType[ColumnType[TProp]] = "concat",
         context: ClauseContextType = None,
     ) -> None:
@@ -33,6 +35,6 @@ class Concat[*Ts](AggregateFunctionBase):
         context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
 
         for clause in self._convert_into_clauseInfo(self.unresolved_column, context=context):
-            clause.alias_clause = None
+            clause.alias_clause = self.alias_clause
             columns.append(clause)
         return self._concat_alias_and_column(f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns)})", self._alias_aggregate)

{ormlambda-3.7.2 → ormlambda-3.11.0}/src/ormlambda/databases/my_sql/join_context.py

@@ -27,12 +27,12 @@ class JoinContext[TParent: Table, TRepo]:
         for comparer, by in self._joins:
             fk_clause, alias = self.get_fk_clause(comparer)
 
-            foreign_key: ForeignKey = ForeignKey(comparer=comparer, clause_name=alias)
+            foreign_key: ForeignKey = ForeignKey(comparer=comparer, clause_name=alias, keep_alive=True)
             fk_clause.alias_table = foreign_key.alias
             self._context.add_clause_to_context(fk_clause)
             setattr(self._parent, alias, foreign_key)
 
-            # TODOH []: We need to preserve the 'foreign_key' variable while inside the 'with' clause.
+            # TODOH [x]: We need to preserve the 'foreign_key' variable while inside the 'with' clause.
             # Keep in mind that 'ForeignKey.stored_calls' is cleared every time we call methods like
             # .select(), .select_one(), .insert(), .update(), or .count(). This means we only retain
             # the context from the first call of any of these methods.
@@ -49,6 +49,7 @@ class JoinContext[TParent: Table, TRepo]:
             fk: ForeignKey = getattr(self._parent, attribute)
             delattr(self._parent, attribute)
             del self._context._table_context[fk.tright]
+            ForeignKey.stored_calls.remove(fk)
         return None
 
     def __getattr__(self, name: str) -> TParent:

{ormlambda-3.7.2 → ormlambda-3.11.0}/src/ormlambda/databases/my_sql/repository/repository.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 import contextlib
 from pathlib import Path
 from typing import Any, Generator, Iterable, Optional, Type, override, TYPE_CHECKING, Unpack
+import uuid
 import shapely as shp
 
 # from mysql.connector.pooling import MySQLConnectionPool
@@ -16,6 +17,7 @@ from ormlambda.caster import Caster
 from ..clauses import CreateDatabase, TypeExists
 from ..clauses import DropDatabase
 from ..clauses import DropTable
+from ..clauses import Alias
 
 
 if TYPE_CHECKING:
@@ -68,12 +70,15 @@ class Response[TFlavour, *Ts]:
 
     def _cast_to_flavour(self, data: list[tuple[*Ts]], **kwargs) -> list[dict[str, tuple[*Ts]]] | list[tuple[*Ts]] | list[TFlavour]:
         def _dict(**kwargs) -> list[dict[str, tuple[*Ts]]]:
+            nonlocal data
             return [dict(zip(self._columns, x)) for x in data]
 
         def _tuple(**kwargs) -> list[tuple[*Ts]]:
+            nonlocal data
             return data
 
         def _set(**kwargs) -> list[set]:
+            nonlocal data
             for d in data:
                 n = len(d)
                 for i in range(n):
@@ -84,12 +89,19 @@ class Response[TFlavour, *Ts]:
             return [set(x) for x in data]
 
         def _list(**kwargs) -> list[list]:
+            nonlocal data
             return [list(x) for x in data]
 
         def _default(**kwargs) -> list[TFlavour]:
-            replacer_dicc: dict[str, str] = {x.alias_clause: x.column for x in self._select.all_clauses}
+            nonlocal data
+            replacer_dicc: dict[str, str] = {}
 
-            cleaned_column_names = [replacer_dicc[col] for col in self._columns]
+            for col in self._select.all_clauses:
+                if hasattr(col, "_alias_aggregate") or col.alias_clause is None or isinstance(col, Alias):
+                    continue
+                replacer_dicc[col.alias_clause] = col.column
+
+            cleaned_column_names = [replacer_dicc.get(col, col) for col in self._columns]
 
             result = []
             for attr in data:
@@ -157,7 +169,34 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
     #
 
     def __init__(self, **kwargs: Unpack[MySQLArgs]):
-        super().__init__(MySQLConnectionPool, **kwargs)
+        timeout = self.__add_connection_timeout(kwargs)
+        name = self.__add_pool_name(kwargs)
+        size = self.__add_pool_size(kwargs)
+        attr = kwargs.copy()
+        attr["connection_timeout"] = timeout
+        attr["pool_name"] = name
+        attr["pool_size"] = size
+
+        super().__init__(MySQLConnectionPool, **attr)
+
+    @staticmethod
+    def __add_connection_timeout(kwargs: MySQLArgs) -> int:
+        if "connection_timeout" not in kwargs.keys():
+            return 60
+        return int(kwargs.pop("connection_timeout"))
+
+    @staticmethod
+    def __add_pool_name(kwargs: MySQLArgs) -> str:
+        if "pool_name" not in kwargs.keys():
+            return str(uuid.uuid4())
+
+        return kwargs.pop("pool_name")
+
+    @staticmethod
+    def __add_pool_size(kwargs: MySQLArgs) -> int:
+        if "pool_size" not in kwargs.keys():
+            return 5
+        return int(kwargs.pop("pool_size"))
 
     @contextlib.contextmanager
     def get_connection(self) -> Generator[MySQLConnection, None, None]:
@@ -254,7 +293,6 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
 
     @override
     def database_exists(self, name: str) -> bool:
-        query = "SHOW DATABASES LIKE %s;"
         temp_config = self._pool._cnx_config
 
         config_without_db = temp_config.copy()
@@ -262,10 +300,11 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
         if "database" in config_without_db:
             config_without_db.pop("database")
         self._pool.set_config(**config_without_db)
+
         with self.get_connection() as cnx:
             with cnx.cursor(buffered=True) as cursor:
-                cursor.execute(query, (name,))
-            res = cursor.fetchmany(1)
+                cursor.execute("SHOW DATABASES LIKE %s;", (name,))
+                res = cursor.fetchmany(1)
 
         self._pool.set_config(**temp_config)
         return len(res) > 0
@@ -276,12 +315,11 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
 
     @override
     def table_exists(self, name: str) -> bool:
-        query = "SHOW TABLES LIKE %s;"
         with self.get_connection() as cnx:
             if not cnx.database:
                 raise Exception("No database selected")
             with cnx.cursor(buffered=True) as cursor:
-                cursor.execute(query, (name,))
+                cursor.execute("SHOW TABLES LIKE %s;", (name,))
             res = cursor.fetchmany(1)
         return len(res) > 0
 
@@ -297,9 +335,17 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
 
     @property
     def database(self) -> Optional[str]:
-        return self._data_config.get("database", None)
+        return self._pool._cnx_config.get("database", None)
 
     @database.setter
     def database(self, value: str) -> None:
-        self._data_config["database"] = value
-        self._pool.set_config(**self._data_config)
+        """Change the current database using USE statement"""
+
+        if not self.database_exists(value):
+            raise ValueError(f"You cannot set the non-existent '{value}' database.")
+
+        old_config: MySQLArgs = self._pool._cnx_config.copy()
+        old_config["database"] = value
+
+        self._pool._remove_connections()
+        self._pool = type(self)(**old_config)._pool