ormlambda 3.7.1__py3-none-any.whl → 3.11.0__py3-none-any.whl

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/caster/base_caster.py

@@ -14,7 +14,7 @@ class BaseCaster[TProp, TType](abc.ABC):
     def wildcard_to_select(self, value: str) -> str: ...
     @overload
     def wildcard_to_select(self) -> str: ...
-    
+
     @abc.abstractmethod
     def wildcard_to_select(self) -> str: ...
 
@@ -22,7 +22,7 @@ class BaseCaster[TProp, TType](abc.ABC):
     def wildcard_to_where(self, value: str) -> str: ...
     @overload
     def wildcard_to_where(self) -> str: ...
-    
+
     @abc.abstractmethod
     def wildcard_to_where(self) -> str: ...
 
@@ -30,7 +30,7 @@ class BaseCaster[TProp, TType](abc.ABC):
     def wildcard_to_insert(self, value: str) -> str: ...
     @overload
     def wildcard_to_insert(self) -> str: ...
-    
+
     @abc.abstractmethod
     def wildcard_to_insert(self) -> str: ...
 

ormlambda/common/global_checker.py

@@ -23,6 +23,6 @@ class GlobalChecker:
         except TypeError as err:
             cond1 = r"takes \d+ positional argument but \d+ were given"
             cond2 = r"missing \d+ required positional arguments:"
-            if re.search(r"("+f"{cond1}|{cond2}"+r")", err.args[0]):
+            if re.search(r"(" + f"{cond1}|{cond2}" + r")", err.args[0]):
                 raise UnmatchedLambdaParameterError(len(tables), obj)
             raise err

ormlambda/components/select/ISelect.py

@@ -6,12 +6,12 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from ormlambda.sql.clause_info import ClauseInfo
 
+
 class ISelect(IQuery):
     @property
     @abc.abstractmethod
-    def FROM(self)->ClauseInfo: ...
-    
+    def FROM(self) -> ClauseInfo: ...
+
     @property
     @abc.abstractmethod
-    def COLUMNS(self)->str: ...
-
+    def COLUMNS(self) -> str: ...

ormlambda/components/select/__init__.py

@@ -1 +1 @@
-from .ISelect import ISelect  # noqa: F401
+from .ISelect import ISelect  # noqa: F401

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/databases/my_sql/caster/types/bytes.py

@@ -6,13 +6,13 @@ class BytesCaster[TType](BaseCaster[bytes, TType]):
     def __init__(self, value: bytes, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str = PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str = PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str = PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     @property

ormlambda/databases/my_sql/caster/types/datetime.py

@@ -8,13 +8,13 @@ class DatetimeCaster[TType](BaseCaster[datetime, TType]):
     def __init__(self, value: datetime, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     @property

ormlambda/databases/my_sql/caster/types/float.py

@@ -6,13 +6,13 @@ class FloatCaster[TType](BaseCaster[float, TType]):
     def __init__(self, value: float, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     @property

ormlambda/databases/my_sql/caster/types/int.py

@@ -6,13 +6,13 @@ class IntegerCaster[TType](BaseCaster[int, TType]):
     def __init__(self, value: int, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     @property

ormlambda/databases/my_sql/caster/types/iterable.py

@@ -6,13 +6,13 @@ class IterableCaster[TType](BaseCaster[bytes, TType]):
     def __init__(self, value: bytes, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     @property

ormlambda/databases/my_sql/caster/types/none.py

@@ -6,13 +6,13 @@ class NoneTypeCaster[TType](BaseCaster[NoneType, TType]):
     def __init__(self, value: NoneType, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     # TODOL: cheched if it's right

ormlambda/databases/my_sql/caster/types/string.py

@@ -6,13 +6,13 @@ class StringCaster[TType](BaseCaster[str, TType]):
     def __init__(self, value: str, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value:str = PLACEHOLDER) -> str:
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_where(self, value:str = PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
         return value
 
-    def wildcard_to_insert(self, value:str = PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
         return value
 
     @property

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/databases/my_sql/clauses/alias.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 import typing as tp
 
-from ormlambda import Table, Column
+from ormlambda import Table
 from ormlambda.sql.clause_info import ClauseInfo
-from ormlambda.common.interfaces.IQueryCommand import IQuery
-from ormlambda.sql.clause_info import ClauseInfoContext, IAggregate
+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
@@ -12,23 +12,17 @@ if tp.TYPE_CHECKING:
     from ormlambda.sql.types import AliasType
 
 
-class Alias[T: Table, TProp](ClauseInfo, IQuery):
-    def __init__(
+class Alias[T: Table](ClauseInfo[T]):
+    def __init__[TProp](
         self,
-        element: IAggregate | ClauseInfo[T] | ColumnType[TProp],
-        alias_clause: tp.Optional[AliasType[ClauseInfo[T]]],
+        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 isinstance(element, Column):
-            context = ClauseInfoContext()
-            element = ClauseInfo(table=element.table, column=element, alias_clause=alias_clause)
-        else:
-            context = ClauseInfoContext(table_context=element.context._table_context, clause_context={})
-            element.context = context
-            element._alias_clause = alias_clause
-
-        self._element = element
-
-    @tp.override
-    @property
-    def query(self) -> str:
-        return self._element.query
+        if not alias_clause:
+            raise TypeError
+        super().__init__(table, column, alias_table, alias_clause, context, keep_asterisk, preserve_context)

ormlambda/databases/my_sql/clauses/group_by.py

@@ -1,32 +1,31 @@
 import typing as tp
-from ormlambda.common.enums.join_type import JoinType
-from ormlambda.sql.clause_info import IAggregate
 from ormlambda import Table
-from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
+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](DecompositionQueryBase[T], IAggregate):
-    CLAUSE: str = "GROUP BY"
+class GroupBy[T: tp.Type[Table], *Ts, TProp](AggregateFunctionBase):
+    @classmethod
+    def FUNCTION_NAME(self) -> str:
+        return "GROUP BY"
 
     def __init__(
         self,
-        table: T,
-        column: tp.Callable[[T, *Ts], TProp],
-        *,
-        alias: bool = True,
-        alias_name: str | None = None,
-        by: JoinType = JoinType.INNER_JOIN,
-    ) -> None:
+        column: ColumnType,
+        context: ClauseInfoContext,
+        **kwargs,
+    ):
         super().__init__(
-            table,
-            columns=column,
-            alias=alias,
-            alias_name=alias_name,
-            by=by,
+            table=column.table,
+            column=column,
+            alias_table=None,
+            alias_clause=None,
+            context=context,
+            **kwargs,
         )
 
     @property
     def query(self) -> str:
-        col: str = ", ".join([x.query for x in self.all_clauses])
-
-        return f"{self.CLAUSE} {col}"
+        column = self._create_query()
+        return f"{self.FUNCTION_NAME()} {column}"

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/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/databases/my_sql/clauses/update.py

@@ -56,7 +56,7 @@ class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase]):
 
             if self.__is_valid__(col):
                 clean_data = CASTER.for_value(value)
-                col_names.append((col.column_name,clean_data.wildcard_to_insert()))
+                col_names.append((col.column_name, clean_data.wildcard_to_insert()))
                 self._values.append(clean_data.to_database)
 
         set_query: str = ",".join(["=".join(col_data) for col_data in col_names])

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/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/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:
@@ -72,4 +73,3 @@ class JoinContext[TParent: Table, TRepo]:
         parent_table = conditions.difference(model).pop()
 
         return clause_dicc[parent_table], clause_dicc[parent_table].table.__name__
-

ormlambda/databases/my_sql/repository/repository.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 import contextlib
 from pathlib import Path
-from typing import Any, Generator, Iterable, Optional, Type, override, TYPE_CHECKING
+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,12 +17,14 @@ 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:
     from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
     from ormlambda import Table
     from ormlambda.databases.my_sql.clauses.select import Select
+    from ..types import MySQLArgs
 
 type TResponse[TFlavour, *Ts] = TFlavour | tuple[dict[str, tuple[*Ts]]] | tuple[tuple[*Ts]] | tuple[TFlavour]
 
@@ -67,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):
@@ -83,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:
@@ -155,8 +168,35 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
 
     #
 
-    def __init__(self, **kwargs):
-        super().__init__(MySQLConnectionPool, **kwargs)
+    def __init__(self, **kwargs: Unpack[MySQLArgs]):
+        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]:
@@ -253,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()
@@ -261,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
@@ -275,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
 
@@ -296,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