ormlambda 2.7.2__tar.gz → 2.8.0__tar.gz

{ormlambda-2.7.2 → ormlambda-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 2.7.2
+Version: 2.8.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

{ormlambda-2.7.2 → ormlambda-2.8.0}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "2.7.2"
+version = "2.8.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"

{ormlambda-2.7.2 → ormlambda-2.8.0}/src/ormlambda/common/interfaces/IStatements.py

@@ -91,7 +91,12 @@ class IStatements[T: Table](ABC):
     # endregion
     # region count
     @abstractmethod
-    def count(self, selection: Callable[[T], property]) -> int: ...
+    def count(
+        self,
+        selection: Callable[[T], property],
+        alias: bool = ...,
+        alias_name: Optional[str] = ...,
+    ) -> int: ...
 
     # endregion
     # region delete
@@ -162,10 +167,30 @@ class IStatements[T: Table](ABC):
     # endregion
     # region max
     @overload
-    def max[TProp](self, column: Callable[[T], TProp], alias: bool = True, alias_name: str = "max") -> TProp: ...
-    @overload
-    def min[TProp](self, column: Callable[[T], TProp], alias: bool = True, alias_name: str = "min") -> TProp: ...
-
+    def max[TProp](
+        self,
+        column: Callable[[T], TProp],
+        alias: bool = ...,
+        alias_name: Optional[str] = ...,
+    ) -> TProp: ...
+    # endregion
+    # region min
+    @overload
+    def min[TProp](
+        self,
+        column: Callable[[T], TProp],
+        alias: bool = ...,
+        alias_name: Optional[str] = ...,
+    ) -> TProp: ...
+    # endregion
+    # region sum
+    @overload
+    def sum[TProp](
+        self,
+        column: Callable[[T], TProp],
+        alias: bool = ...,
+        alias_name: Optional[str] = ...,
+    ) -> TProp: ...
     # endregion
     # region select
     @overload
@@ -231,7 +256,7 @@ class IStatements[T: Table](ABC):
     # endregion
     # region group_by
     @abstractmethod
-    def group_by[TRepo, *Ts](self, column: Callable[[T], TRepo], select_query: Callable[[T], tuple[*Ts]]) -> tuple[tuple[*Ts]]: ...
+    def group_by[TRepo, *Ts](self, column: Callable[[T], TRepo]) -> IStatements[T]: ...
 
     # endregion
 

{ormlambda-2.7.2 → ormlambda-2.8.0}/src/ormlambda/databases/my_sql/clauses/__init__.py

@@ -13,4 +13,4 @@ from .update import UpdateQuery as UpdateQuery
 from .upsert import UpsertQuery as UpsertQuery
 from .where_condition import WhereCondition as WhereCondition
 from .count import Count as Count
-from ..functions.group_by import GroupBy as GroupBy
+from .group_by import GroupBy as GroupBy

{ormlambda-2.7.2/src/ormlambda/databases/my_sql/functions → ormlambda-2.8.0/src/ormlambda/databases/my_sql/clauses}/group_by.py

@@ -25,8 +25,6 @@ class GroupBy[T: tp.Type[Table], TProp](DecompositionQueryBase[T], IAggregate[T]
             by=by,
         )
 
-        self._column: TProp = column
-
     def alias_children_resolver[Tclause: tp.Type[Table]](self, clause_info: ClauseInfo[Tclause]):
         return None
 

ormlambda-2.8.0/src/ormlambda/databases/my_sql/functions/__init__.py

@@ -0,0 +1,5 @@
+from .max import Max as Max
+from .min import Min as Min
+from .concat import Concat as Concat
+from ..clauses.group_by import GroupBy as GroupBy
+from .sum import Sum as Sum

ormlambda-2.8.0/src/ormlambda/databases/my_sql/functions/sum.py

@@ -0,0 +1,39 @@
+from ormlambda.common.interfaces import IAggregate
+import typing as tp
+
+from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase, ClauseInfo
+
+if tp.TYPE_CHECKING:
+    from ormlambda import Table
+
+
+class Sum[T: tp.Type[Table]](DecompositionQueryBase[T], IAggregate[T]):
+    NAME: str = "SUM"
+
+    @tp.overload
+    def __init__[T: tp.Type[Table]](self, table: T, column: tp.Callable[[T], tp.Any], *, alias: bool = True, alias_name: str = ...) -> None: ...
+
+    def __init__(
+        self,
+        table: T,
+        column: str | tp.Callable[[T], tuple],
+        *,
+        alias: bool = True,
+        alias_name: str = "sum",
+    ) -> None:
+        super().__init__(
+            table,
+            lambda_query=column,
+            alias=alias,
+            alias_name=alias_name,
+        )
+
+    def alias_children_resolver[Tclause: tp.Type[Table]](self, clause_info: ClauseInfo[Tclause]):
+        if isinstance(clause_info._row_column, IAggregate):
+            return clause_info._row_column.alias
+        return None
+
+    @property
+    def query(self) -> str:
+        col = ", ".join([x.query for x in self.all_clauses])
+        return f"{self.NAME}({col})"

{ormlambda-2.7.2 → ormlambda-2.8.0}/src/ormlambda/databases/my_sql/statements.py

@@ -128,11 +128,13 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         return self
 
     @override
-    def count(self, selection: Callable[[T], tuple] = lambda x: "*") -> int:
-        count_select: IQuery = Select[T](self._model, lambda x: Count[T](self._model, selection))
-        self._query_list["select"].append(count_select)
-        query = self._build()
-        return self.repository.read_sql(query)[0][0]
+    def count(
+        self,
+        selection: Callable[[T], tuple] = lambda x: "*",
+        alias=True,
+        alias_name=None,
+    ) -> IQuery:
+        return Count[T](self._model, selection, alias=alias, alias_name=alias_name)
 
     @override
     def join(self, table_left: Table, table_right: Table, *, by: str) -> IStatements_two_generic[T, MySQLConnection]:
@@ -172,6 +174,10 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
     def min[TProp](self, column: Callable[[T], TProp], alias: bool = True, alias_name: str = "min") -> TProp:
         return func.Min[T](self._model, column=column, alias=alias, alias_name=alias_name)
 
+    @override
+    def sum[TProp](self, column: Callable[[T], TProp], alias: bool = True, alias_name: str = "sum") -> TProp:
+        return func.Sum[T](self._model, column=column, alias=alias, alias_name=alias_name)
+
     @override
     def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Optional[Type[TFlavour]] = None, by: JoinType = JoinType.INNER_JOIN):
         if len(inspect.signature(selector).parameters) == 0:
@@ -211,8 +217,14 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         return tuple([res[0] for res in response])
 
     @override
-    def group_by[TRepo, *Ts](self, column: Callable[[T], TRepo], select_query: Callable[[T], tuple[*Ts]]) -> tuple[tuple[*Ts]]:
-        return GroupBy[T, TRepo, tuple[*Ts]](self._model, column, select_query)
+    def group_by[*Ts](self, column: str | Callable[[T], Any]) -> IStatements_two_generic[T, MySQLConnection]:
+        if isinstance(column, str):
+            groupby = GroupBy[T, tuple[*Ts]](self._model, lambda x: column)
+        else:
+            groupby = GroupBy[T, tuple[*Ts]](self._model, column)
+        # Only can be one LIMIT SQL parameter. We only use the last LimitQuery
+        self._query_list["group by"].append(groupby)
+        return self
 
     @override
     def _build(self) -> str:

ormlambda-2.7.2/src/ormlambda/databases/my_sql/functions/__init__.py

@@ -1,4 +0,0 @@
-from .max import Max  # noqa: F401
-from .min import Min  # noqa: F401
-from .concat import Concat  # noqa: F401
-from .group_by import GroupBy  # noqa: F401