ormlambda 1.0.1__tar.gz → 1.2.0__tar.gz

{ormlambda-1.0.1 → ormlambda-1.2.0}/PKG-INFO

@@ -1,16 +1,20 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 1.0.1
+Version: 1.2.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: mysql-connector (>=2.2.9,<3.0.0)
-Requires-Dist: ruff (>=0.4.5,<0.5.0)
+Requires-Dist: fluent-validation (>=3.1.0,<4.0.0)
+Requires-Dist: mysql-connector-python (>=2.2.9,<3.0.0)
 Description-Content-Type: text/markdown
 
+![PyPI version](https://img.shields.io/pypi/v/ormlambda.svg)
+![downloads](https://img.shields.io/pypi/dm/ormlambda?label=downloads)
+![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)
+
 # ormMySQL
 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. 
 
@@ -19,7 +23,7 @@ This ORM is designed to connect with a MySQL server, facilitating the management
 ## Initialize MySQLRepository
 ```python
 from decouple import config
-from src.ormmysql.databases.my_sql import MySQLRepository
+from ormlambda.databases.my_sql import MySQLRepository
 
 USERNAME = config("USERNAME")
 PASSWORD = config("PASSWORD")
@@ -31,7 +35,7 @@ database = MySQLRepository(user=USERNAME, password=PASSWORD, database="sakila",
 
 ## Select all columns
 ```python
-from src.test.models.address import AddressModel
+from models.address import AddressModel
 
 result = AddressModel(database).select()
 ```
@@ -41,8 +45,8 @@ The `result` var will be of type `tuple[Address, ...]`
 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."
 
 ```python
-from src.ormmysql.common.enums import ConditionType
-from src.test.models.address import AddressModel
+from ormlambda import ConditionType
+from models.address import AddressModel
 
 
 result = AddressModel(database).where(lambda x: (x.City.Country, ConditionType.REGEXP, r"^[aA]")).select(
@@ -135,13 +139,13 @@ The easiest way to map your tables is:
 ```python
 from datetime import datetime
 
-from src.ormmysql import (
+from ormlambda import (
     Column,
     Table,
     BaseModel,
     ForeignKey,
 )
-from src.ormmysql.common.interfaces import IStatements_two_generic, IRepositoryBase
+from ormlambda.common.interfaces import IStatements_two_generic, IRepositoryBase
 
 
 class Country(Table):

{ormlambda-1.0.1 → ormlambda-1.2.0}/README.md

@@ -1,3 +1,7 @@
+![PyPI version](https://img.shields.io/pypi/v/ormlambda.svg)
+![downloads](https://img.shields.io/pypi/dm/ormlambda?label=downloads)
+![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)
+
 # ormMySQL
 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. 
 
@@ -6,7 +10,7 @@ This ORM is designed to connect with a MySQL server, facilitating the management
 ## Initialize MySQLRepository
 ```python
 from decouple import config
-from src.ormmysql.databases.my_sql import MySQLRepository
+from ormlambda.databases.my_sql import MySQLRepository
 
 USERNAME = config("USERNAME")
 PASSWORD = config("PASSWORD")
@@ -18,7 +22,7 @@ database = MySQLRepository(user=USERNAME, password=PASSWORD, database="sakila",
 
 ## Select all columns
 ```python
-from src.test.models.address import AddressModel
+from models.address import AddressModel
 
 result = AddressModel(database).select()
 ```
@@ -28,8 +32,8 @@ The `result` var will be of type `tuple[Address, ...]`
 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."
 
 ```python
-from src.ormmysql.common.enums import ConditionType
-from src.test.models.address import AddressModel
+from ormlambda import ConditionType
+from models.address import AddressModel
 
 
 result = AddressModel(database).where(lambda x: (x.City.Country, ConditionType.REGEXP, r"^[aA]")).select(
@@ -122,13 +126,13 @@ The easiest way to map your tables is:
 ```python
 from datetime import datetime
 
-from src.ormmysql import (
+from ormlambda import (
     Column,
     Table,
     BaseModel,
     ForeignKey,
 )
-from src.ormmysql.common.interfaces import IStatements_two_generic, IRepositoryBase
+from ormlambda.common.interfaces import IStatements_two_generic, IRepositoryBase
 
 
 class Country(Table):

{ormlambda-1.0.1 → ormlambda-1.2.0}/pyproject.toml

@@ -3,19 +3,18 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "1.0.1"
+version = "1.2.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 = "^2.2.9"
-ruff = "^0.4.5"
+mysql-connector-python= "^2.2.9"
+fluent-validation = "^3.1.0"
 
 [tool.poetry.group.test.dependencies]
 pandas = "^2.2.2"
-mysql-connector = "^2.2.9"
 ruff = "^0.4.5"
 python-decouple = "^3.8"
 

ormlambda-1.2.0/src/ormlambda/__init__.py

@@ -0,0 +1,10 @@
+# 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 .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-1.0.1 → ormlambda-1.2.0}/src/ormlambda/common/__init__.py

@@ -1,2 +1 @@
 
-

{ormlambda-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.2.0/src/ormlambda/common/enums/__init__.py

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

{ormlambda-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/ormlambda/common/interfaces/IRepositoryBase.py

@@ -65,3 +65,7 @@ class IRepositoryBase[T](ABC):
     def set_config(self, value: dict[str, Any]) -> dict[str, Any]:
         """Method to update database config"""
         ...
+
+    @property
+    @abstractmethod
+    def database(self) -> Optional[str]: ...

{ormlambda-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.0.1 → ormlambda-1.2.0}/src/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-1.2.0/src/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-1.2.0/src/ormlambda/databases/my_sql/clauses/create_database.py

@@ -0,0 +1,36 @@
+from typing import Literal, override
+from mysql.connector import errorcode, errors
+from mysql.connector import MySQLConnection
+
+from ormlambda import IRepositoryBase
+
+TypeExists = Literal["fail", "replace", "append"]
+
+
+class CreateDatabase:
+    def __init__(self, repository: IRepositoryBase[MySQLConnection]) -> None:
+        self._repository: IRepositoryBase[MySQLConnection] = repository
+
+    @override
+    @property
+    def CLAUSE(self) -> str:
+        return "CREATE DATABASE"
+
+    @override
+    def execute(self, name: str, if_exists: TypeExists = "fail") -> None:
+        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