ormlambda 1.5.0__py3-none-any.whl → 2.0.2__py3-none-any.whl

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
 
 

ormlambda/databases/my_sql/clauses/upsert.py

@@ -1,8 +1,8 @@
 from typing import override, Any
 
-from ....utils import Table
-from ....components.upsert import UpsertQueryBase
-from ....common.interfaces import IRepositoryBase
+from ormlambda import Table
+from ormlambda.components.upsert import UpsertQueryBase
+from ormlambda import IRepositoryBase
 from mysql.connector import MySQLConnection
 
 from .insert import InsertQuery

ormlambda/databases/my_sql/clauses/where_condition.py

@@ -1,11 +1,11 @@
 from typing import Any, Callable, Optional, override
 import inspect
 
-from ....common.enums import ConditionType
-from ....utils.lambda_disassembler.tree_instruction import TreeInstruction, TupleInstruction
-from ....common.interfaces.IQueryCommand import IQuery
-from ....components.where.abstract_where import AbstractWhere
-from ....utils import Table
+from ormlambda.common.enums import ConditionType
+from ormlambda.utils.lambda_disassembler.tree_instruction import TreeInstruction, TupleInstruction
+from ormlambda.common.interfaces.IQueryCommand import IQuery
+from ormlambda.components.where.abstract_where import AbstractWhere
+from ormlambda import Table
 
 
 class WhereConditionByArg[TProp1, TProp2](IQuery):

ormlambda/databases/my_sql/repository.py

@@ -1,14 +1,15 @@
-# Standard libraries
+from __future__ import annotations
 from pathlib import Path
-from typing import Any, Type, override
-
+from typing import Any, Optional, Type, override, Callable
+import functools
 
 # from mysql.connector.pooling import MySQLConnectionPool
 from mysql.connector import MySQLConnection, Error  # noqa: F401
+from mysql.connector.pooling import PooledMySQLConnection, MySQLConnectionPool  # noqa: F401
 
 # Custom libraries
-from ...common.interfaces import IRepositoryBase
-from ...utils.module_tree.dynamic_module import ModuleTree
+from ormlambda import IRepositoryBase
+from ormlambda.utils.module_tree.dynamic_module import ModuleTree
 
 from .clauses import CreateDatabase, TypeExists
 from .clauses import DropDatabase
@@ -51,39 +52,66 @@ class Response[TFlavour, *Ts]:
         def _tuple() -> list[tuple[*Ts]]:
             return data
 
+        def _set() -> list[set]:
+            for d in data:
+                n = len(d)
+                for i in range(n):
+                    try:
+                        hash(d[i])
+                    except TypeError:
+                        raise TypeError(f"unhashable type '{type(d[i])}' found in '{type(d)}' when attempting to cast the result into a '{set.__name__}' object")
+            return [set(x) for x in data]
+
         def _default() -> list[TFlavour]:
             return [self._flavour(x, **self._kwargs) for x in data]
 
-        selector: dict[Type[object], Any] = {dict: _dict, tuple: _tuple}
+        selector: dict[Type[object], Any] = {
+            dict: _dict,
+            tuple: _tuple,
+            set: _set,
+        }
 
         return selector.get(self._flavour, _default)()
 
 
 class MySQLRepository(IRepositoryBase[MySQLConnection]):
+    def get_connection(func: Callable[..., Any]):
+        @functools.wraps(func)
+        def wrapper(self: IRepositoryBase[MySQLConnection], *args, **kwargs):
+            self.connect()
+            try:
+                foo = func(self, *args, **kwargs)
+            finally:
+                self.connection.rollback()
+                self.close_connection()
+            return foo
+
+        return wrapper
+
     def __init__(self, **kwargs: Any) -> None:
         self._data_config: dict[str, Any] = kwargs
-        self._connection: MySQLConnection = MySQLConnection()
-        # self._pool_connection: MySQLConnection = MySQLConnection(**kwargs)
-        pass
+        self._pool: MySQLConnectionPool = self.__create_MySQLConnectionPool()
+        self._connection: PooledMySQLConnection = None
 
+    def __create_MySQLConnectionPool(self):
+        return MySQLConnectionPool(pool_name="mypool",pool_size=10, **self._data_config)
     @override
     def is_connected(self) -> bool:
-        return self._connection.is_connected()
+        return self._connection._cnx is not None if self._connection else False
 
     @override
-    def connect(self) -> IRepositoryBase[MySQLConnection]:
-        # return MySQLConnectionPool(pool_name="mypool", pool_size=5, **kwargs)
-        self._connection.connect(**self._data_config)
+    def connect(self) -> None:
+        self._connection = self._pool.get_connection()
         return None
 
     @override
     def close_connection(self) -> None:
-        if self._connection.is_connected():
+        if self.is_connected():
             self._connection.close()
         return None
 
     @override
-    @IRepositoryBase.check_connection
+    @get_connection
     def read_sql[TFlavour](self, query: str, flavour: Type[TFlavour] = tuple, **kwargs) -> tuple[TFlavour]:
         """
         Return tuple of tuples by default.
@@ -101,7 +129,7 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
             return Response[TFlavour](response_values=values, columns=columns, flavour=flavour, **kwargs).response
 
     # FIXME [ ]: this method does not comply with the implemented interface
-    @IRepositoryBase.check_connection
+    @get_connection
     def create_tables_code_first(self, path: str | Path) -> None:
         if not isinstance(path, Path | str):
             raise ValueError
@@ -123,7 +151,7 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         return None
 
     @override
-    @IRepositoryBase.check_connection
+    @get_connection
     def executemany_with_values(self, query: str, values) -> None:
         with self._connection.cursor(buffered=True) as cursor:
             cursor.executemany(query, values)
@@ -131,7 +159,7 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         return None
 
     @override
-    @IRepositoryBase.check_connection
+    @get_connection
     def execute_with_values(self, query: str, values) -> None:
         with self._connection.cursor(buffered=True) as cursor:
             cursor.execute(query, values)
@@ -139,7 +167,7 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         return None
 
     @override
-    @IRepositoryBase.check_connection
+    @get_connection
     def execute(self, query: str) -> None:
         with self._connection.cursor(buffered=True) as cursor:
             cursor.execute(query)
@@ -147,12 +175,11 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         return None
 
     @override
-    @IRepositoryBase.check_connection
     def drop_table(self, name: str) -> None:
         return DropTable(self).execute(name)
 
     @override
-    @IRepositoryBase.check_connection
+    @get_connection
     def database_exists(self, name: str) -> bool:
         query = "SHOW DATABASES LIKE %s;"
         with self._connection.cursor(buffered=True) as cursor:
@@ -161,12 +188,11 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         return len(res) > 0
 
     @override
-    @IRepositoryBase.check_connection
     def drop_database(self, name: str) -> None:
         return DropDatabase(self).execute(name)
 
     @override
-    @IRepositoryBase.check_connection
+    @get_connection
     def table_exists(self, name: str) -> bool:
         if not self._connection.database:
             raise Exception("No database selected")
@@ -178,7 +204,6 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         return len(res) > 0
 
     @override
-    @IRepositoryBase.check_connection
     def create_database(self, name: str, if_exists: TypeExists = "fail") -> None:
         return CreateDatabase(self).execute(name, if_exists)
 
@@ -187,6 +212,11 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
     def connection(self) -> MySQLConnection:
         return self._connection
 
-    @override
-    def set_config(self, value: dict[str, Any]) -> dict[str, Any]:
-        return self._data_config.update(value)
+    @property
+    def database(self) -> Optional[str]:
+        return self._data_config.get("database", None)
+
+    @database.setter
+    def database(self, value: str) -> None:
+        self._data_config["database"] = value
+        self._pool = self.__create_MySQLConnectionPool()