ormlambda 2.6.0__py3-none-any.whl → 2.7.2__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

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Any, Literal, Optional, Type
+from typing import Literal, Optional, Type
 
 TypeExists = Literal["fail", "replace", "append"]
 
@@ -8,15 +8,6 @@ class IRepositoryBase[T](ABC):
     def __repr__(self) -> str:
         return f"{IRepositoryBase.__name__}: {self.__class__.__name__}"
 
-    @abstractmethod
-    def is_connected(self) -> bool: ...
-
-    @abstractmethod
-    def connect(self, **kwargs: Any) -> None: ...
-
-    @abstractmethod
-    def close_connection(self) -> None: ...
-
     @abstractmethod
     def read_sql[TFlavour](self, query: str, flavour: Optional[Type[TFlavour]], **kwargs) -> tuple[TFlavour]: ...
 
@@ -44,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,21 @@ 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: ...
 
     # endregion
-
     # region delete
     @overload
     def delete(self) -> None: ...
@@ -108,28 +107,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 +126,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 +143,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 +155,18 @@ 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 = True, alias_name: str = "max") -> TProp: ...
+    @overload
+    def min[TProp](self, column: Callable[[T], TProp], alias: bool = True, alias_name: str = "min") -> TProp: ...
 
+    # endregion
     # region select
     @overload
     def select(self) -> tuple[T, ...]: ...
@@ -212,7 +208,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,7 +229,6 @@ 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]]: ...

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,4 @@
 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

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/repository.py

@@ -77,45 +77,27 @@ class Response[TFlavour, *Ts]:
 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)
-            except Exception as e:
-                self.connection.rollback()
-                raise e
-            finally:
-                self.close_connection()
-            return foo
+        def wrapper(self: MySQLRepository, *args, **kwargs):
+            with self._pool.get_connection() as cnx:
+                try:
+                    foo = func(self, cnx._cnx, *args, **kwargs)
+                    return foo
+                except Exception as e:
+                    cnx._cnx.rollback()
+                    raise e
 
         return wrapper
 
     def __init__(self, **kwargs: Any) -> None:
         self._data_config: dict[str, Any] = kwargs
         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._cnx is not None if self._connection else False
-
-    @override
-    def connect(self) -> None:
-        self._connection = self._pool.get_connection()
-        return None
-
-    @override
-    def close_connection(self) -> None:
-        if self.is_connected():
-            self._connection.close()
-        return None
-
     @override
     @get_connection
-    def read_sql[TFlavour](self, query: str, flavour: Type[TFlavour] = tuple, **kwargs) -> tuple[TFlavour]:
+    def read_sql[TFlavour](self, cnx: MySQLConnection, query: str, flavour: Type[TFlavour] = tuple, **kwargs) -> tuple[TFlavour]:
         """
         Return tuple of tuples by default.
 
@@ -125,7 +107,7 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
             - flavour: Type[TFlavour]: Useful to return tuple of any Iterable type as dict,set,list...
         """
 
-        with self._connection._cnx.cursor(buffered=True) as cursor:
+        with cnx.cursor(buffered=True) as cursor:
             cursor.execute(query)
             values: list[tuple] = cursor.fetchall()
             columns: tuple[str] = cursor.column_names
@@ -133,7 +115,7 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
 
     # FIXME [ ]: this method does not comply with the implemented interface
     @get_connection
-    def create_tables_code_first(self, path: str | Path) -> None:
+    def create_tables_code_first(self, cnx: MySQLConnection, path: str | Path) -> None:
         if not isinstance(path, Path | str):
             raise ValueError
 
@@ -148,33 +130,33 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
         queries_list: list[str] = module_tree.get_queries()
 
         for query in queries_list:
-            with self._connection._cnx.cursor(buffered=True) as cursor:
+            with cnx.cursor(buffered=True) as cursor:
                 cursor.execute(query)
-        self._connection._cnx.commit()
+        cnx.commit()
         return None
 
     @override
     @get_connection
-    def executemany_with_values(self, query: str, values) -> None:
-        with self._connection._cnx.cursor(buffered=True) as cursor:
+    def executemany_with_values(self, cnx: MySQLConnection, query: str, values) -> None:
+        with cnx.cursor(buffered=True) as cursor:
             cursor.executemany(query, values)
-        self._connection._cnx.commit()
+        cnx.commit()
         return None
 
     @override
     @get_connection
-    def execute_with_values(self, query: str, values) -> None:
-        with self._connection._cnx.cursor(buffered=True) as cursor:
+    def execute_with_values(self, cnx: MySQLConnection, query: str, values) -> None:
+        with cnx.cursor(buffered=True) as cursor:
             cursor.execute(query, values)
-        self._connection._cnx.commit()
+        cnx.commit()
         return None
 
     @override
     @get_connection
-    def execute(self, query: str) -> None:
-        with self._connection._cnx.cursor(buffered=True) as cursor:
+    def execute(self, cnx: MySQLConnection, query: str) -> None:
+        with cnx.cursor(buffered=True) as cursor:
             cursor.execute(query)
-        self._connection._cnx.commit()
+        cnx.commit()
         return None
 
     @override
@@ -183,9 +165,9 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
 
     @override
     @get_connection
-    def database_exists(self, name: str) -> bool:
+    def database_exists(self, cnx: MySQLConnection, name: str) -> bool:
         query = "SHOW DATABASES LIKE %s;"
-        with self._connection._cnx.cursor(buffered=True) as cursor:
+        with cnx.cursor(buffered=True) as cursor:
             cursor.execute(query, (name,))
             res = cursor.fetchmany(1)
         return len(res) > 0
@@ -196,12 +178,12 @@ class MySQLRepository(IRepositoryBase[MySQLConnection]):
 
     @override
     @get_connection
-    def table_exists(self, name: str) -> bool:
-        if not self._connection._cnx.database:
+    def table_exists(self, cnx: MySQLConnection, name: str) -> bool:
+        if not cnx.database:
             raise Exception("No database selected")
 
         query = "SHOW TABLES LIKE %s;"
-        with self._connection._cnx.cursor(buffered=True) as cursor:
+        with cnx.cursor(buffered=True) as cursor:
             cursor.execute(query, (name,))
             res = cursor.fetchmany(1)
         return len(res) > 0
@@ -210,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]):
@@ -140,9 +142,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 +160,18 @@ 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 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:
@@ -198,24 +218,33 @@ class MySQLStatements[T: Table](AbstractSQLStatements[T, MySQLConnection]):
     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 +256,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.0.dist-info → ormlambda-2.7.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 2.6.0
+Version: 2.7.2
 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.0.dist-info → ormlambda-2.7.2.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=iWZ9X2qjvacZHdbykrE5wAMyi-4LJLKcNvtNTGD6S-8,1398
-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=dlH8rL0flsF6QuvDsOb3LuM-FhtO9_D64SDjz07f3zg,10296
 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
@@ -42,17 +42,18 @@ ormlambda/databases/my_sql/clauses/insert.py,sha256=LO9H8VVK3j62dICXqpEUXKxOHPxk
 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=XpLhHssbw43-0NRDpY0T9SKhyedzCQOCGQWdrfHvbVw,155
 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=3IQX8z6g5N1e7FVFCr-kEnKoi_E_N3aCQ_MA5q_bHnc,7566
-ormlambda/databases/my_sql/statements.py,sha256=4o1NguIiNOVA9i8hqaUMJdIfgn1MvXnnJhJABKPJtF0,9660
+ormlambda/databases/my_sql/functions/min.py,sha256=SEVuUdIJNz9zM5za1kLTWalFkhErjsjyBb8SU8n0F94,1190
+ormlambda/databases/my_sql/repository.py,sha256=fSAAmO_T5mC1bodOVZn5CY9JSfRq4VhsdlWT1JLl7Zw,6927
+ormlambda/databases/my_sql/statements.py,sha256=NTAZs9TDEI_KoH0GNG2Ea8oTFckXeTfTg_cdUHSYziA,11493
 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 +70,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.0.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
-ormlambda-2.6.0.dist-info/METADATA,sha256=HtLgvKuUEcQqDadfokBM0qyxTjTUSNOoErjtJ3aMdGk,8428
-ormlambda-2.6.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ormlambda-2.6.0.dist-info/RECORD,,
+ormlambda-2.7.2.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
+ormlambda-2.7.2.dist-info/METADATA,sha256=8CXacsolfAa439Blpjufzi4bSOTOjked1fz4C_4gYZ4,8428
+ormlambda-2.7.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ormlambda-2.7.2.dist-info/RECORD,,