ormlambda 2.6.1__py3-none-any.whl → 2.8.0__py3-none-any.whl

ormlambda/common/abstract_classes/abstract_model.py

@@ -76,7 +76,7 @@ class ClusterQuery[T]:
                 for clause in clauses:
                     if not hasattr(table, clause.column):
                         agg_methods = self.get_all_aggregate_method(clauses)
-                        raise ValueError(f"You cannot use aggregation method like '{agg_methods}' to return model objects")
+                        raise ValueError(f"You cannot use aggregation method like '{agg_methods}' to return model objects. Try specifying 'flavour' attribute as 'dict'.")
                     valid_attr[clause.column] = dicc_cols[clause.alias]
 
                 # COMMENT: At this point we are going to instantiate Table class with specific attributes getting directly from database

ormlambda/common/abstract_classes/decomposition_query.py

@@ -28,7 +28,6 @@ class ClauseInfo[T: tp.Type[Table]]:
         self._alias: tp.Optional[str] = self._alias_children_resolver(self)
 
         self._query: str = self.__create_value_string(self._column)
-        pass
 
     def __repr__(self) -> str:
         return f"{ClauseInfo.__name__}: {self.query}"

ormlambda/common/interfaces/IDecompositionQuery.py

@@ -31,7 +31,7 @@ class IDecompositionQuery[T: tp.Type[Table]](IQuery):
 
     @property
     @abc.abstractmethod
-    def fk_relationship(self) -> tuple[tuple[tp.Type[Table], tp.Type[Table]]]: ...
+    def fk_relationship(self) -> set[tuple[tp.Type[Table], tp.Type[Table]]]: ...
 
     @property
     @abc.abstractmethod

ormlambda/common/interfaces/IRepositoryBase.py

@@ -35,10 +35,6 @@ class IRepositoryBase[T](ABC):
     @abstractmethod
     def database_exists(self, name: str) -> bool: ...
 
-    @property
-    @abstractmethod
-    def connection(self) -> T: ...
-
     @property
     @abstractmethod
     def database(self) -> Optional[str]: ...

ormlambda/common/interfaces/IStatements.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Any, Callable, Iterable, Optional, Literal, Type, overload, TYPE_CHECKING
+from typing import Any, Callable, Iterable, Optional, Literal, Type, Union, overload, TYPE_CHECKING, TypeVar
 from enum import Enum
 from abc import abstractmethod, ABC
 
@@ -8,12 +8,16 @@ from ormlambda.common.enums import JoinType
 
 if TYPE_CHECKING:
     from ormlambda import Table
+    from .IAggregate import IAggregate
 
 OrderType = Literal["ASC", "DESC"]
 
 # TODOH: This var is duplicated from 'src\ormlambda\databases\my_sql\clauses\create_database.py'
 TypeExists = Literal["fail", "replace", "append"]
 
+T = TypeVar("T")
+WhereTypes = Union[Callable[[T], bool], Iterable[Callable[[T], bool]]]
+
 
 class IStatements[T: Table](ABC):
     @abstractmethod
@@ -45,7 +49,6 @@ class IStatements[T: Table](ABC):
     def insert(self, values: T | list[T]) -> None: ...
 
     # endregion
-
     # region upsert
     @overload
     def upsert(self, values: T) -> None:
@@ -76,25 +79,26 @@ class IStatements[T: Table](ABC):
     def update(self, dicc: dict[str | property, Any]) -> None: ...
 
     # endregion
-
     # region limit
     @abstractmethod
     def limit(self, number: int) -> IStatements[T]: ...
 
     # endregion
-
     # region offset
     @abstractmethod
     def offset(self, number: int) -> IStatements[T]: ...
 
     # 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
     @overload
     def delete(self) -> None: ...
@@ -108,28 +112,15 @@ class IStatements[T: Table](ABC):
     def delete(self, instance: Optional[T | list[T]] = None) -> None: ...
 
     # endregion
-
     # region join
     @abstractmethod
     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]:
-        """
-        This method creates where clause by passing the lambda's condition
-
-        EXAMPLE
-        -
-        mb = BaseModel()
-        mb.where(lambda a: 10 <= a.city_id <= 100)
-        """
-        ...
 
     @overload
-    def where(self, lambda_: Callable[[T], Iterable]) -> IStatements[T]:
+    def where(self, conditions: Iterable[Callable[[T], bool]]) -> IStatements[T]:
         """
         This method creates where clause by passing the Iterable in lambda function
         EXAMPLE
@@ -140,7 +131,7 @@ class IStatements[T: Table](ABC):
         ...
 
     @overload
-    def where(self, lambda_: Callable[[T], bool], **kwargs) -> IStatements[T]:
+    def where(self, conditions: Callable[[T], bool], **kwargs) -> IStatements[T]:
         """
         PARAM
         -
@@ -157,10 +148,9 @@ class IStatements[T: Table](ABC):
         ...
 
     @abstractmethod
-    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> IStatements[T]: ...
+    def where(self, conditions: WhereTypes = lambda: None, **kwargs) -> IStatements[T]: ...
 
     # endregion
-
     # region order
     @overload
     def order[TValue](self, _lambda_col: Callable[[T], TValue]) -> IStatements[T]: ...
@@ -170,7 +160,38 @@ class IStatements[T: Table](ABC):
     def order[TValue](self, _lambda_col: Callable[[T], TValue], order_type: OrderType) -> IStatements[T]: ...
 
     # endregion
+    # region concat
+    @overload
+    def concat[*Ts](self, selector: Callable[[T], tuple[*Ts]]) -> IAggregate[T]: ...
 
+    # endregion
+    # region max
+    @overload
+    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
     def select(self) -> tuple[T, ...]: ...
@@ -212,7 +233,6 @@ class IStatements[T: Table](ABC):
     def select[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Type[TFlavour] = None, by: JoinType = JoinType.INNER_JOIN): ...
 
     # endregion
-
     # region select_one
     @overload
     def select_one(self) -> T: ...
@@ -234,10 +254,9 @@ class IStatements[T: Table](ABC):
     def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Type[TFlavour] = None, by: Optional[Enum] = JoinType.INNER_JOIN): ...
 
     # 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/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/databases/my_sql/{functions → 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/databases/my_sql/clauses/order.py

@@ -1,4 +1,8 @@
-from typing import override, Callable
+from __future__ import annotations
+from typing import override, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda import Table
 
 from ormlambda.utils.lambda_disassembler.tree_instruction import TreeInstruction
 from ormlambda.common.interfaces.IQueryCommand import IQuery
@@ -8,7 +12,7 @@ ASC = "ASC"
 DESC = "DESC"
 
 
-class OrderQuery[T](IQuery):
+class OrderQuery[T:Table](IQuery):
     ORDER = "ORDER BY"
 
     def __init__(self, instance: T, order_lambda: Callable[[T], None], order_type: OrderType) -> None:

ormlambda/databases/my_sql/clauses/select.py

@@ -2,6 +2,7 @@ from typing import override, Type, Callable, TYPE_CHECKING
 
 from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
 from ormlambda.common.enums.join_type import JoinType
+from ormlambda.common.interfaces.IAggregate import IAggregate
 
 if TYPE_CHECKING:
     from ormlambda import Table
@@ -34,7 +35,15 @@ class Select[T: Type[Table]](DecompositionQueryBase[T]):
     @override
     @property
     def query(self) -> str:
-        col: str = ", ".join([x.query for x in self.all_clauses])
+        cols:list[str] = []
+        for x in self.all_clauses:
+            cols.append(x.query)
+
+            if isinstance(x._row_column,IAggregate) and x._row_column.has_foreign_keys:
+                self._fk_relationship.update(x._row_column.fk_relationship)
+
+
+        col: str = ", ".join(cols)
         query: str = f"{self.CLAUSE} {col} FROM {self._table.__table_name__}"
         alias = ""
 

ormlambda/databases/my_sql/functions/__init__.py

@@ -1,3 +1,5 @@
-from .max import Max  # noqa: F401
-from .concat import Concat  # noqa: F401
-from .group_by import GroupBy  # noqa: F401
+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/databases/my_sql/functions/min.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 Min[T: tp.Type[Table]](DecompositionQueryBase[T], IAggregate[T]):
+    NAME: str = "MIN"
+
+    @tp.overload
+    def __init__[T: tp.Type[Table]](self, table: T, column: tp.Callable[[T], tp.Any], *, alias: bool = True, alias_name: str = "min") -> None: ...
+
+    def __init__(
+        self,
+        table: T,
+        column: str | tp.Callable[[T], tuple],
+        *,
+        alias: bool = True,
+        alias_name: str = "min",
+    ) -> 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/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/databases/my_sql/repository.py

@@ -80,10 +80,10 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         def wrapper(self: MySQLRepository, *args, **kwargs):
             with self._pool.get_connection() as cnx:
                 try:
-                    foo = func(self, cnx, *args, **kwargs)
+                    foo = func(self, cnx._cnx, *args, **kwargs)
                     return foo
                 except Exception as e:
-                    self.connection.rollback()
+                    cnx._cnx.rollback()
                     raise e
 
         return wrapper
@@ -192,10 +192,6 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
     def create_database(self, name: str, if_exists: TypeExists = "fail") -> None:
         return CreateDatabase(self).execute(name, if_exists)
 
-    @override
-    @property
-    def connection(self) -> MySQLConnection:
-        return self._connection
 
     @property
     def database(self) -> Optional[str]:

ormlambda/databases/my_sql/statements.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
-from typing import override, Type, TYPE_CHECKING, Any, Callable, Optional
+from typing import Iterable, override, Type, TYPE_CHECKING, Any, Callable, Optional
+import inspect
+from mysql.connector import MySQLConnection, errors, errorcode
+
 
 if TYPE_CHECKING:
     from ormlambda import Table
@@ -7,6 +10,8 @@ if TYPE_CHECKING:
     from ormlambda.common.interfaces.IStatements import OrderType
     from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
     from ormlambda.common.interfaces.IRepositoryBase import TypeExists
+    from ormlambda.common.interfaces import IAggregate
+    from ormlambda.common.interfaces.IStatements import WhereTypes
 
 from ormlambda import AbstractSQLStatements
 from .clauses import DeleteQuery
@@ -23,13 +28,10 @@ from .clauses import WhereCondition
 from .clauses import Count
 from .clauses import GroupBy
 
-from mysql.connector import MySQLConnection, errors, errorcode
-
-
-import inspect
 
 from ormlambda.utils import ForeignKey, Table
 from ormlambda.common.enums import JoinType
+from . import functions as func
 
 
 class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
@@ -126,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]:
@@ -140,9 +144,15 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         return self
 
     @override
-    def where(self, lambda_: Callable[[T], bool] = lambda: None, **kwargs) -> IStatements_two_generic[T, MySQLConnection]:
+    def where(self, conditions: WhereTypes = lambda: None, **kwargs) -> IStatements_two_generic[T, MySQLConnection]:
         # FIXME [x]: I've wrapped self._model into tuple to pass it instance attr. Idk if it's correct
-        where_query = WhereCondition[T](function=lambda_, instances=(self._model,), **kwargs)
+
+        if isinstance(conditions, Iterable):
+            for x in conditions:
+                self._query_list["where"].append(WhereCondition[T](function=x, instances=(self._model,), **kwargs))
+            return self
+
+        where_query = WhereCondition[T](function=conditions, instances=(self._model,), **kwargs)
         self._query_list["where"].append(where_query)
         return self
 
@@ -152,6 +162,22 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
         self._query_list["order"].append(order)
         return self
 
+    @override
+    def concat[*Ts](self, selector: Callable[[T], tuple[*Ts]], alias: bool = True, alias_name: str = "CONCAT") -> IAggregate[T]:
+        return func.Concat[T](self._model, selector, alias=alias, alias_name=alias_name)
+
+    @override
+    def max[TProp](self, column: Callable[[T], TProp], alias: bool = True, alias_name: str = "max") -> TProp:
+        return func.Max[T](self._model, column=column, alias=alias, alias_name=alias_name)
+
+    @override
+    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:
@@ -191,31 +217,46 @@ 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:
         query: str = ""
 
-        # self.__create_necessary_inner_join()
         for x in self.__order__:
             sub_query: Optional[list[IQuery]] = self._query_list.get(x, None)
-            if sub_query is not None:
-                if isinstance(sub_query[0], WhereCondition):
-                    query_ = self.__build_where_clause(sub_query)
-
-                # we must check if any join already exists on query string
-                elif isinstance(sub_query[0], JoinSelector):
-                    select_query: str = self._query_list["select"][0].query
-                    query_ = ""
-                    for join in sub_query:
-                        if join.query not in select_query:
-                            query_ += f"\n{join.query}"
-                else:
-                    query_ = "\n".join([x.query for x in sub_query])
-
-                query += f"\n{query_}" if query != "" else query_
+            if sub_query is None:
+                continue
+
+            if isinstance(sub_query[0], WhereCondition):
+                query_ = self.__build_where_clause(sub_query)
+
+            # we must check if any join already exists on query string
+            elif isinstance(sub_query[0], JoinSelector):
+                select_query: str = self._query_list["select"][0].query
+                query_ = ""
+                for join in sub_query:
+                    if join.query not in select_query:
+                        query_ += f"\n{join.query}"
+
+            elif isinstance((select := sub_query[0]), Select):
+                query_: str = ""
+                where_joins = self.__create_necessary_inner_join()
+                if where_joins:
+                    select._fk_relationship.update(where_joins)
+                query_ = select.query
+
+            else:
+                query_ = "\n".join([x.query for x in sub_query])
+
+            query += f"\n{query_}" if query != "" else query_
         self._query_list.clear()
         return query
 
@@ -227,3 +268,19 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
             and_, clause = q.split(" ", maxsplit=1)
             query += f" {and_} ({clause})"
         return query
+
+    def __create_necessary_inner_join(self) -> Optional[set[tuple[Type[Table], Type[Table]]]]:
+        # When we applied filters in any table that we wont select any column, we need to add manually all neccessary joins to achieve positive result.
+        if "where" not in self._query_list:
+            return None
+
+        res = []
+        for where in self._query_list["where"]:
+            where: AbstractWhere
+
+            tables = where.get_involved_tables()
+
+            if tables:
+                [res.append(x) for x in tables]
+
+        return set(res)

{ormlambda-2.6.1.dist-info → ormlambda-2.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 2.6.1
+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.6.1.dist-info → ormlambda-2.8.0.dist-info}/RECORD

@@ -1,19 +1,19 @@
 ormlambda/__init__.py,sha256=L-Enc4FPmW3ldBMnWOU3gLn9i4FEc7sQzLWy2mIEti8,538
 ormlambda/common/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 ormlambda/common/abstract_classes/__init__.py,sha256=tk2J4Mn_nD-1ZjtMVBE5FH7KR_8ppN_1Kx1s6c38GjM,167
-ormlambda/common/abstract_classes/abstract_model.py,sha256=1v86bTuSxsFzy5RUc9HnraRVjbGezJoqLbizcrMo-Uc,4548
-ormlambda/common/abstract_classes/decomposition_query.py,sha256=OReQs1SEf02FnJI8SDreXp2agkjRqyj_RJrFiMn55ro,11409
+ormlambda/common/abstract_classes/abstract_model.py,sha256=0mGoW-MF0bX1VrAp2AJZ8Nk_BV7N_2NtzZoUFCg5Wm4,4595
+ormlambda/common/abstract_classes/decomposition_query.py,sha256=c-Vo0f2dnVCv9Qsmqt9AZaZAYvyYhtZFdc3HKyHCMZ0,11396
 ormlambda/common/abstract_classes/non_query_base.py,sha256=5jhvyT7OZaJxlGp9XMP3vQ4ei5QQZBn-fFtJnD640mE,980
 ormlambda/common/abstract_classes/query_base.py,sha256=6qUFPwsVx45kUW3b66pHiSyjhcH4mzbdkddlGeUnG7c,266
 ormlambda/common/enums/__init__.py,sha256=4lVKCHi1JalwgNzjsAXqX-C54NJEH83y2v5baMO8fN4,103
 ormlambda/common/enums/condition_types.py,sha256=mDPMrtzZu4IYv3-q5Zw4NNgwUoNAx4lih5SIDFRn1Qo,309
 ormlambda/common/enums/join_type.py,sha256=7LEhE34bzYOwJxe8yxPJo_EjQpGylgClAPX1Wt3z4n4,292
 ormlambda/common/interfaces/IAggregate.py,sha256=i9zZIYrstP2oolUYqR-udeQQl7M0NwSzrr-VUL0b5HI,271
-ormlambda/common/interfaces/IDecompositionQuery.py,sha256=VwZdYhVApNyGrWgqr27mRMOxREMb6Xv-oYtW_0c2D2g,1365
+ormlambda/common/interfaces/IDecompositionQuery.py,sha256=dHdCxezbWwy-c4U4po2hQB8f_wa0wGFvA2TKaHBx0Do,1363
 ormlambda/common/interfaces/INonQueryCommand.py,sha256=7CjLW4sKqkR5zUIGvhRXOtzTs6vypJW1a9EJHlgCw2c,260
 ormlambda/common/interfaces/IQueryCommand.py,sha256=hfzCosK4-n8RJIb2PYs8b0qU3TNmfYluZXBf47KxxKs,331
-ormlambda/common/interfaces/IRepositoryBase.py,sha256=jIwQ6c_eadf3K7dyvBf88kTIb6AqIsIYBc2aJ90RS0I,1196
-ormlambda/common/interfaces/IStatements.py,sha256=zsjR6JnQ57M6GPGRqAXkuuwZx6fh3Mq6NB4D6gWw-3w,10028
+ormlambda/common/interfaces/IRepositoryBase.py,sha256=zGm7tDrFLKj3FMYN-MWI-em3INws27g2yByNYYMx0qk,1126
+ormlambda/common/interfaces/IStatements.py,sha256=df3pGRFSwyBcFct0ntMy8E9RNCHreXTO-qirdetS05M,10674
 ormlambda/common/interfaces/__init__.py,sha256=00ca9a-u_A8DzyEyxPfBMxfqLKFzzUgJaeNmoRitAbA,360
 ormlambda/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ormlambda/components/delete/IDelete.py,sha256=06ZEdbKBxsHSwsGMBu0E1om4WJjojZAm-L3b95eQrcc,139
@@ -32,27 +32,29 @@ ormlambda/components/where/__init__.py,sha256=mI-ylB6cTTVf3rtCX54apgZrMP6y9tTD7-
 ormlambda/components/where/abstract_where.py,sha256=93tIJBC81OUUVV6il7mISibBwqJeodQdFFQ9DShDKOQ,344
 ormlambda/databases/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ormlambda/databases/my_sql/__init__.py,sha256=3PbOp4WqxJzFOSRwBozqyNtQi25cLLdiJFPDzEnSI70,115
-ormlambda/databases/my_sql/clauses/__init__.py,sha256=OG_cLBAWOeJt4oq-OYXyDd_idbGgYvO_9bnV_hz3Fvg,778
+ormlambda/databases/my_sql/clauses/__init__.py,sha256=F7p---sNQBefi_dgydV6Wp1YuOwDzvSQOdbcjWtBi2k,767
 ormlambda/databases/my_sql/clauses/count.py,sha256=UFJD-ELp-xvOyPbvYX37GvRZsP8M_axambnI7_h91yA,1177
 ormlambda/databases/my_sql/clauses/create_database.py,sha256=WnWaAuhxeE71NZKXW37WZ-msRqjum7TFCSRK1IGdSTE,1279
 ormlambda/databases/my_sql/clauses/delete.py,sha256=nUKNQgwF5YUfzk2icWpecYjrGk5DeXpp7eiwtWCf_3c,1924
 ormlambda/databases/my_sql/clauses/drop_database.py,sha256=nMM0YUbcH0D9X3bU70Uc6S_dsIrAZy-IrYuIKrQZNrg,505
 ormlambda/databases/my_sql/clauses/drop_table.py,sha256=meX4e-pVPQ7UwlPSHV5e9HHRblI1BlkLSc7ssl8WUiI,592
+ormlambda/databases/my_sql/clauses/group_by.py,sha256=xG8YhdaDWBm99EFMkzCsBJNhHOJy5lvXmpaHu3jClro,1042
 ormlambda/databases/my_sql/clauses/insert.py,sha256=LO9H8VVK3j62dICXqpEUXKxOHPxkD1LGvogmDq2zmho,2805
 ormlambda/databases/my_sql/clauses/joins.py,sha256=U6JnUvQo7AXyEeK-X1jMvckXefgAB7ugSmJCZhH1XQI,3058
 ormlambda/databases/my_sql/clauses/limit.py,sha256=a4lI8FVRKpfXwBQTXdkbVtlQkmzcjE20ymiCy1IaSc4,391
 ormlambda/databases/my_sql/clauses/offset.py,sha256=81170JhsQndjKlDfQj1ll-tiYHQbW8SuU4IE3mhQF7Y,395
-ormlambda/databases/my_sql/clauses/order.py,sha256=AcTD7aeaaz-isyjs1_CkRCb7z8b7o5GhpMxc_2G5IgI,1030
-ormlambda/databases/my_sql/clauses/select.py,sha256=NQFBoxTeJxFBEJJ8SIKr_06BYEeblOuP4J_9YD_iJxI,1280
+ormlambda/databases/my_sql/clauses/order.py,sha256=RVqyEtD0InnOPAmRvjtNJ-vrAy0V9OHMLoFB8TkpX0I,1137
+ormlambda/databases/my_sql/clauses/select.py,sha256=unJBteFK5D360KnIPyqz8OMaVJqXJlI5Kkp6u0JJ1vU,1574
 ormlambda/databases/my_sql/clauses/update.py,sha256=3Htw0_PT3EckEiF214-V2r63lcNoRBroKZI9yg48Ddg,1867
 ormlambda/databases/my_sql/clauses/upsert.py,sha256=eW2pQ4ax-GKuXiaWKoSRSS1GrHuILJBsmj83ADbBQ34,1951
 ormlambda/databases/my_sql/clauses/where_condition.py,sha256=UgU5vnTqFAx91wKwnECpww5tETDZ9F7IdC_SiZOgZhI,8336
-ormlambda/databases/my_sql/functions/__init__.py,sha256=jUFHlFc04UAPht65GlEkLXa5_dwfBl2c377ohrNXswc,120
+ormlambda/databases/my_sql/functions/__init__.py,sha256=hA8t3mUpV2p-pO4TVp5rjC5Yp7aIkWPsS8NpLi3DUh0,171
 ormlambda/databases/my_sql/functions/concat.py,sha256=cZztl5eSATpYMKVKfyPbul6OocaUkaEGpt3uWmhf-3o,1177
-ormlambda/databases/my_sql/functions/group_by.py,sha256=ym1L6RBA70hmzrkJ-IA_-6Esq7eoVgNdf1vWpqxRq-8,1080
 ormlambda/databases/my_sql/functions/max.py,sha256=zrO_RBKsHhyokEmSpPI6Yg5OY6Jf4GGp2RveBJdOuuA,1190
-ormlambda/databases/my_sql/repository.py,sha256=KltLdpWFiPaHKFOVcefy3pQ0g_pBFsUVlpBFV7CGEEk,7034
-ormlambda/databases/my_sql/statements.py,sha256=4o1NguIiNOVA9i8hqaUMJdIfgn1MvXnnJhJABKPJtF0,9660
+ormlambda/databases/my_sql/functions/min.py,sha256=SEVuUdIJNz9zM5za1kLTWalFkhErjsjyBb8SU8n0F94,1190
+ormlambda/databases/my_sql/functions/sum.py,sha256=akKYr2dI8TZS5MDvybfHn_idhPOvEH0cj6mDRQIHe-M,1188
+ormlambda/databases/my_sql/repository.py,sha256=fSAAmO_T5mC1bodOVZn5CY9JSfRq4VhsdlWT1JLl7Zw,6927
+ormlambda/databases/my_sql/statements.py,sha256=inUEyLUl3Z6TxE7PpJUWw0SZBoO_JbnrS_XL_wCyHn4,11873
 ormlambda/model_base.py,sha256=RrAATQWX_bHJ0ZQ5sCHyJKA4NiR7ZJY4I6dqhnGWWAc,1216
 ormlambda/utils/__init__.py,sha256=ywMdWqmA2jHj19-W-S04yfaYF5hv4IZ1lZDq0B8Jnjs,142
 ormlambda/utils/column.py,sha256=5FAGzCU4yvNS4MhwJJ5i73h7RvHD5UCVox0NdzMsMiE,1945
@@ -69,7 +71,7 @@ ormlambda/utils/module_tree/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 ormlambda/utils/module_tree/dfs_traversal.py,sha256=lSF03G63XtJFLp03ueAmsHMBvhUkjptDbK3IugXm8iU,1425
 ormlambda/utils/module_tree/dynamic_module.py,sha256=zwvjU3U2cz6H2CDp9Gncs5D5bSAyfITNa2SDqFDl8rw,8551
 ormlambda/utils/table_constructor.py,sha256=8Apm44K6MiYMK3PQyK74MUV18OatbFI9eDLAVklQO0w,11660
-ormlambda-2.6.1.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
-ormlambda-2.6.1.dist-info/METADATA,sha256=OUhV3mP2xqwH75LftvCqJis1Kmx00sBUnazCPG5DrOQ,8428
-ormlambda-2.6.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ormlambda-2.6.1.dist-info/RECORD,,
+ormlambda-2.8.0.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
+ormlambda-2.8.0.dist-info/METADATA,sha256=HV3vUXqD2StgsPEk4VwRtPLp44DRjIUgSoMTRsWAkNw,8428
+ormlambda-2.8.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ormlambda-2.8.0.dist-info/RECORD,,