ormlambda 2.9.4__py3-none-any.whl → 2.11.1__py3-none-any.whl

ormlambda/common/abstract_classes/decomposition_query.py

@@ -6,17 +6,26 @@ import abc
 from ormlambda import Table
 
 from ormlambda.utils.lambda_disassembler.tree_instruction import TreeInstruction, TupleInstruction, NestedElement
-from ormlambda.common.interfaces import IAggregate, IDecompositionQuery
+from ormlambda.common.interfaces import IAggregate, IDecompositionQuery, ICustomAlias
+from ormlambda.common.interfaces.IDecompositionQuery import IDecompositionQuery_one_arg
 from ormlambda import JoinType, ForeignKey
 from ormlambda.databases.my_sql.clauses.joins import JoinSelector
 
-from ..errors import DifferentTablesAndVariablesError
+from ..errors import UnmatchedLambdaParameterError
 
-type ClauseDataType = property | str
+type ClauseDataType = property | str | ICustomAlias
 type AliasType[T] = tp.Type[Table] | tp.Callable[[tp.Type[Table]], T]
 
+type ValueType = tp.Union[
+    property,
+    IAggregate,
+    Table,
+    str,
+    ICustomAlias,
+]
 
-class ClauseInfo[T: tp.Type[Table]]:
+
+class ClauseInfo[T: tp.Type[Table]](IDecompositionQuery_one_arg[T]):
     @tp.overload
     def __init__(self, table: T, column: property, alias_children_resolver: tp.Callable[..., str]): ...
     @tp.overload
@@ -34,6 +43,10 @@ class ClauseInfo[T: tp.Type[Table]]:
     def __repr__(self) -> str:
         return f"{ClauseInfo.__name__}: {self.query}"
 
+    @property
+    def table(self) -> T:
+        return self._table
+
     @property
     def column(self) -> ClauseDataType:
         return self._column
@@ -64,6 +77,12 @@ class ClauseInfo[T: tp.Type[Table]]:
             # TODOL: refactor to base the condition in dict with '*' as key. '*' must to work as special character
             return f"'{data}'" if data != DecompositionQueryBase.CHAR else data
 
+        elif isinstance(data, ICustomAlias):
+            return data.all_clauses[0].column
+
+        else:
+            raise NotImplementedError(f"type of value '{type(data)}' is not implemented.")
+
     def __create_value_string(self, name: str) -> str:
         if isinstance(self._row_column, property):
             return self.concat_with_alias(f"{self._table.__table_name__}.{name}")
@@ -74,11 +93,9 @@ class ClauseInfo[T: tp.Type[Table]]:
         return self.concat_with_alias(self.column)
 
     def concat_with_alias(self, column_name: str) -> str:
-        alias: None | str = self._alias_children_resolver(self)
-
-        if not alias:
+        if not self._alias:
             return column_name
-        return f"{column_name} as `{alias}`"
+        return f"{column_name} as `{self._alias}`"
 
 
 class DecompositionQueryBase[T: tp.Type[Table], *Ts](IDecompositionQuery[T, *Ts]):
@@ -154,6 +171,9 @@ class DecompositionQueryBase[T: tp.Type[Table], *Ts](IDecompositionQuery[T, *Ts]
         """
         lambda_vars = tuple(inspect.signature(_lambda).parameters)
 
+        if len(lambda_vars) != (expected := len(self._tables)):
+            raise UnmatchedLambdaParameterError(expected, found_param=lambda_vars)
+
         # COMMENT: We don't pass a lambda method because lambda reads the las value of 'i'
         for i, param in enumerate(lambda_vars):
             self.alias_cache[param] = self._tables[i]
@@ -162,20 +182,18 @@ class DecompositionQueryBase[T: tp.Type[Table], *Ts](IDecompositionQuery[T, *Ts]
     def __clauses_list_generetor(self, function: tp.Callable[[T], tp.Any]) -> None:
         if not callable(function):
             return None
-        try:
-            resolved_function = function(*self._tables)
-        except TypeError:
-            raise DifferentTablesAndVariablesError
+
+        resolved_function = function(*self._tables)
 
         tree_list = TreeInstruction(function).to_list()
         # Python treats string objects as iterable, so we need to prevent this behavior
         if isinstance(resolved_function, str) or not isinstance(resolved_function, tp.Iterable):
             resolved_function = (resolved_function,)
 
-        for col_index, last_data in enumerate(resolved_function):
+        for col_index, data in enumerate(resolved_function):
             ti = tree_list[col_index] if tree_list else TupleInstruction(self.CHAR, NestedElement(self.CHAR))
 
-            values: ClauseInfo | list[ClauseInfo] = self.__identify_value_type(last_data, ti)
+            values: ClauseInfo | list[ClauseInfo] = self.__identify_value_type(data, ti)
 
             if isinstance(values, tp.Iterable):
                 [self.__add_clause(x) for x in values]
@@ -184,50 +202,74 @@ class DecompositionQueryBase[T: tp.Type[Table], *Ts](IDecompositionQuery[T, *Ts]
 
         return None
 
-    def __identify_value_type[TProp](self, last_data: TProp, tuple_instruction: TupleInstruction) -> ClauseInfo[T]:
+    def __identify_value_type[TProp](self, data: TProp, tuple_instruction: TupleInstruction) -> ClauseInfo[T]:
         """
         A method that behaves based on the variable's type
         """
 
-        if isinstance(last_data, property):
-            if tuple_instruction.var == self.CHAR:
-                table_left = self.table
-            else:
-                table_left = self.alias_cache[tuple_instruction.var]
-
-            if last_data in table_left.__properties_mapped__:
-                # if self.table != table_left:
-                #     self._add_fk_relationship(self.table, table_left)
-                return ClauseInfo[T](table_left, last_data, self.alias_children_resolver)
-
-            for table in self.tables:
-                try:
-                    return self._search_correct_table_for_prop(table, tuple_instruction, last_data)
-                except ValueError:
-                    continue
-
-        elif isinstance(last_data, IAggregate):
-            return ClauseInfo[T](self.table, last_data, self.alias_children_resolver)
-
-        # if value is a Table instance (when you need to retrieve all columns) we'll ensure that all JOINs are added
-        elif isinstance(last_data, type) and issubclass(last_data, Table):
-            if last_data not in self._tables:
-                self.__add_necessary_fk(tuple_instruction, last_data)
-            # all columns
-            clauses: list[ClauseInfo] = []
-            for prop in last_data.__properties_mapped__:
-                if isinstance(prop, property):
-                    clauses.append(self.__identify_value_type(prop, tuple_instruction))
-            return clauses
-
-        elif isinstance(last_data, str):
-            # COMMENT: use self.table instead self._tables because if we hit this conditional, means that
-            # COMMENT: alias_cache to replace '*' by all columns
-            if self._replace_asterisk_char and (replace_value := self.alias_cache.get(last_data, None)) is not None:
-                return self.__identify_value_type(replace_value(self.table), tuple_instruction)
-            return ClauseInfo[T](self.table, last_data, alias_children_resolver=self.alias_children_resolver)
-
-        raise NotImplementedError(f"type of value '{last_data}' is not implemented.")
+        def validation(data: TProp, type_: ValueType):
+            is_table: bool = isinstance(data, type) and issubclass(data, type_)
+            return any(
+                [
+                    isinstance(data, type_),
+                    is_table,
+                ]
+            )
+
+        value_type_mapped: dict[tp.Type[ValueType], tp.Callable[[TProp, TupleInstruction], ClauseInfo[T]]] = {
+            property: self._property_type,
+            IAggregate: self._IAggregate_type,
+            Table: self._table_type,
+            str: self._str_type,
+            ICustomAlias: self._ICustomAlias_type,
+        }
+
+        function = next((handler for cls, handler in value_type_mapped.items() if validation(data, cls)), None)
+
+        if not function:
+            raise NotImplementedError(f"type of value '{data}' is not implemented.")
+
+        return function(data, tuple_instruction)
+
+    def _property_type(self, data: property, ti: TupleInstruction):
+        if ti.var == self.CHAR:
+            table_left = self.table
+        else:
+            table_left = self.alias_cache[ti.var]
+
+        if data in table_left.__properties_mapped__:
+            # if self.table != table_left:
+            #     self._add_fk_relationship(self.table, table_left)
+            return ClauseInfo[T](table_left, data, self.alias_children_resolver)
+
+        for table in self.tables:
+            try:
+                return self._search_correct_table_for_prop(table, ti, data)
+            except ValueError:
+                continue
+
+    def _IAggregate_type(self, data: IAggregate, ti: TupleInstruction):
+        return ClauseInfo[T](self.table, data, self.alias_children_resolver)
+
+    def _table_type(self, data: tp.Type[Table], ti: TupleInstruction):
+        if data not in self._tables:
+            self.__add_necessary_fk(ti, data)
+        # all columns
+        clauses: list[ClauseInfo] = []
+        for prop in data.__properties_mapped__:
+            if isinstance(prop, property):
+                clauses.append(self.__identify_value_type(prop, ti))
+        return clauses
+
+    def _str_type(self, data: str, ti: TupleInstruction):
+        # COMMENT: use self.table instead self._tables because if we hit this conditional, means that
+        # COMMENT: alias_cache to replace '*' by all columns
+        if self._replace_asterisk_char and (replace_value := self.alias_cache.get(data, None)) is not None:
+            return self.__identify_value_type(replace_value(self.table), ti)
+        return ClauseInfo[T](self.table, data, alias_children_resolver=self.alias_children_resolver)
+
+    def _ICustomAlias_type(self, data: ICustomAlias, ti: TupleInstruction):
+        return ClauseInfo(data.table, data, data.alias_children_resolver)
 
     def _search_correct_table_for_prop[TTable](self, table: tp.Type[Table], tuple_instruction: TupleInstruction, prop: property) -> ClauseInfo[TTable]:
         temp_table: tp.Type[Table] = table
@@ -251,7 +293,7 @@ class DecompositionQueryBase[T: tp.Type[Table], *Ts](IDecompositionQuery[T, *Ts]
 
     def __add_clause[Tc: tp.Type[Table]](self, clause: ClauseInfo[Tc]) -> None:
         self._all_clauses.append(clause)
-        self._clauses_group_by_tables[clause._table].append(clause)
+        self._clauses_group_by_tables[clause.table].append(clause)
         return None
 
     def __add_necessary_fk(self, tuple_instruction: TupleInstruction, tables: tp.Type[Table]) -> None:

ormlambda/common/errors/__init__.py

@@ -1,3 +1,8 @@
-class DifferentTablesAndVariablesError(Exception):
+class UnmatchedLambdaParameterError(Exception):
+    def __init__(self, expected_params: int, found_param: tuple[str, ...], *args: object) -> None:
+        super().__init__(*args)
+        self.expected_params = expected_params
+        self.found_param: tuple[str, ...] = found_param
+
     def __str__(self) -> str:
-        return "The number of tables and the variables used in the lambda select are not 'consistent'"
+        return f"Unmatched number of parameters in lambda function with the number of tables: Expected {self.expected_params} parameters but found {str(self.found_param)}."

ormlambda/common/interfaces/ICustomAlias.py

@@ -1,4 +1,4 @@
 from ormlambda.common.interfaces import IDecompositionQuery
 
 
-class ICustomAlias[T,*Ts](IDecompositionQuery[T,*Ts]): ...
+class ICustomAlias[T, *Ts](IDecompositionQuery[T, *Ts]): ...

ormlambda/common/interfaces/IDecompositionQuery.py

@@ -12,11 +12,17 @@ if tp.TYPE_CHECKING:
 from .IQueryCommand import IQuery
 
 
-class IDecompositionQuery[T: tp.Type[Table], *Ts](IQuery):
+class IDecompositionQuery_one_arg[T: tp.Type[Table]](IQuery):
     @property
     @abc.abstractmethod
     def table(self) -> T: ...
 
+    @property
+    @abc.abstractmethod
+    def alias(self) -> bool: ...
+
+
+class IDecompositionQuery[T: tp.Type[Table], *Ts](IDecompositionQuery_one_arg[T], IQuery):
     @property
     @abc.abstractmethod
     def tables(self) -> tuple[*Ts]: ...
@@ -37,14 +43,6 @@ class IDecompositionQuery[T: tp.Type[Table], *Ts](IQuery):
     @abc.abstractmethod
     def fk_relationship(self) -> set[tuple[tp.Type[Table], tp.Type[Table]]]: ...
 
-    @property
-    @abc.abstractmethod
-    def query(self) -> str: ...
-
-    @property
-    @abc.abstractmethod
-    def alias(self) -> bool: ...
-
     @property
     @abc.abstractmethod
     def alias_name(self) -> tp.Optional[str]: ...

ormlambda/common/interfaces/IStatements.py

@@ -35,7 +35,7 @@ type SelectRes10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] = tuple[*SelectRes9[T1
 
 
 type WhereCondition[T, T1] = Callable[[T, T1], bool]
-type JoinCondition[T, T1] = tuple[T1, WhereCondition[T, T1]]
+type JoinCondition[T, T1] = tuple[T1, WhereCondition[T, T1], Optional[JoinType]]
 
 type TupleJoins1[T, T1] = tuple[JoinCondition[T, T1]]
 type TupleJoins2[T, T1, T2] = tuple[*TupleJoins1[T, T1], JoinCondition[T, T2]]
@@ -227,22 +227,29 @@ class IStatements[T, *Ts](ABC):
     # region join
 
     @overload
-    def join[T1](self, joins: JoinCondition[T, T1]) -> IStatements[T, T1]: ...
+    def join[T1](self, table: T1, relation: WhereCondition[T, T1], join_type: Optional[JoinType]) -> IStatements[T, T1]: ...
     @overload
-    def join[T1](self, joins: TupleJoins1[T, T1]) -> IStatements[T, T1]: ...
+    def join[T1](self, table: JoinCondition[T, T1]) -> IStatements[T, T1]: ...
     @overload
-    def join[T1, T2](self, joins: TupleJoins2[T, T1, T2]) -> IStatements[T, T1, T2]: ...
+    def join[T1](self, table: TupleJoins1[T, T1]) -> IStatements[T, T1]: ...
     @overload
-    def join[T1, T2, T3](self, joins: TupleJoins3[T, T1, T2, T3]) -> IStatements[T, T1, T2, T3]: ...
+    def join[T1, T2](self, table: TupleJoins2[T, T1, T2]) -> IStatements[T, T1, T2]: ...
     @overload
-    def join[T1, T2, T3, T4](self, joins: TupleJoins4[T, T1, T2, T3, T4]) -> IStatements[T, T1, T2, T3, T4]: ...
+    def join[T1, T2, T3](self, table: TupleJoins3[T, T1, T2, T3]) -> IStatements[T, T1, T2, T3]: ...
     @overload
-    def join[T1, T2, T3, T4, T5](self, joins: TupleJoins5[T, T1, T2, T3, T4, T5]) -> IStatements[T, T1, T2, T3, T4, T5]: ...
+    def join[T1, T2, T3, T4](self, table: TupleJoins4[T, T1, T2, T3, T4]) -> IStatements[T, T1, T2, T3, T4]: ...
     @overload
-    def join[T1, T2, T3, T4, T5, T6](self, joins: TupleJoins6[T, T1, T2, T3, T4, T5, T6]) -> IStatements[T, T1, T2, T3, T4, T5, T6]: ...
+    def join[T1, T2, T3, T4, T5](self, table: TupleJoins5[T, T1, T2, T3, T4, T5]) -> IStatements[T, T1, T2, T3, T4, T5]: ...
+    @overload
+    def join[T1, T2, T3, T4, T5, T6](self, table: TupleJoins6[T, T1, T2, T3, T4, T5, T6]) -> IStatements[T, T1, T2, T3, T4, T5, T6]: ...
 
     @abstractmethod
-    def join[*FKTables](self, joins) -> IStatements[T, *FKTables]: ...
+    def join[*FKTables](
+        self,
+        table: Optional[T] = ...,
+        relation: Optional[WhereCondition[T, FKTables]] = ...,
+        join_type: Optional[JoinType] = ...,
+    ) -> IStatements[T, *FKTables]: ...
 
     # endregion
     # region select
@@ -304,7 +311,13 @@ class IStatements[T, *Ts](ABC):
     @overload
     def select_one[TFlavour](self, selector: Callable[[T, *Ts], tuple], *, by: Optional[Enum] = ..., flavour: Type[TFlavour]) -> TFlavour: ...
     @abstractmethod
-    def select_one[TValue, TFlavour, *Ts](self, selector: Optional[Callable[[T, *Ts], tuple[TValue, *Ts]]] = lambda: None, *, flavour: Type[TFlavour] = ..., by: Optional[Enum] = ...): ...
+    def select_one[TValue, TFlavour, *Ts](
+        self,
+        selector: Optional[Callable[[T, *Ts], tuple[TValue, *Ts]]] = lambda: None,
+        *,
+        flavour: Type[TFlavour] = ...,
+        by: Optional[Enum] = ...,
+    ): ...
 
     # endregion
     # region group_by
@@ -316,6 +329,9 @@ class IStatements[T, *Ts](ABC):
     @abstractmethod
     def _build(self) -> str: ...
 
+    @abstractmethod
+    def alias(self, column: Callable[[T, *Ts], Any], alias: str) -> IStatements[T, *Ts]: ...
+
 
 class IStatements_two_generic[T: Table, *Ts, TRepo](IStatements[T, *Ts]):
     @property

ormlambda/common/interfaces/__init__.py

@@ -1,6 +1,7 @@
-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 .IDecompositionQuery import IDecompositionQuery  # noqa: F401
-from .IAggregate import IAggregate  # noqa: F401
+from .IQueryCommand import IQuery as IQuery
+from .INonQueryCommand import INonQueryCommand as INonQueryCommand
+from .IRepositoryBase import IRepositoryBase as IRepositoryBase
+from .IStatements import IStatements as IStatements, IStatements_two_generic as IStatements_two_generic
+from .IDecompositionQuery import IDecompositionQuery as IDecompositionQuery
+from .IAggregate import IAggregate as IAggregate
+from .ICustomAlias import ICustomAlias as ICustomAlias

ormlambda/databases/my_sql/clauses/__init__.py

@@ -14,3 +14,4 @@ from .upsert import UpsertQuery as UpsertQuery
 from .where_condition import WhereCondition as WhereCondition
 from .count import Count as Count
 from .group_by import GroupBy as GroupBy
+from .alias import Alias as Alias

ormlambda/databases/my_sql/clauses/alias.py

@@ -5,7 +5,7 @@ from ormlambda import Table
 from ormlambda.common.interfaces import ICustomAlias
 
 
-class Alias[T: tp.Type[Table], *Ts](DecompositionQueryBase[T,*Ts], ICustomAlias[T,*Ts]):
+class Alias[T: tp.Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ICustomAlias[T, *Ts]):
     def __init__(
         self,
         table: T,

ormlambda/databases/my_sql/clauses/where_condition.py

@@ -5,6 +5,7 @@ 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.common.errors import UnmatchedLambdaParameterError
 from ormlambda import Table
 
 
@@ -69,7 +70,9 @@ class WhereCondition[T: Type[Table], *Inst](AbstractWhere):
         """
         The method is responsible for mapping the variables present in the lambda function so that they are replaced with the instance of the model Table.
         """
-        assert len(lamda_param := inspect.signature(self._function).parameters) == len(self._instances)
+        lamda_param = inspect.signature(self._function).parameters
+        if len(lamda_param) != (expected := len(self._instances)):
+            raise UnmatchedLambdaParameterError(expected, found_param=tuple(lamda_param))
 
         _temp_instances = list(self._instances)[::-1]  # we copied and translated tuple instance due to pop each value in order to param
         new_dicc: dict[str, Table] = {}

ormlambda/databases/my_sql/statements.py

@@ -30,6 +30,7 @@ from .clauses import UpdateQuery
 from .clauses import WhereCondition
 from .clauses import Count
 from .clauses import GroupBy
+from .clauses import Alias
 
 
 from ormlambda.utils import Table
@@ -157,7 +158,7 @@ class MySQLStatements[T: Table, *Ts](AbstractSQLStatements[T, *Ts, MySQLConnecti
                 self._query_list["where"].append(WhereCondition[T](function=x, instances=self._models, **kwargs))
             return self
 
-        where_query = WhereCondition[T](function=conditions, instances=(self._model,), **kwargs)
+        where_query = WhereCondition[T](function=conditions, instances=self._models, **kwargs)
         self._query_list["where"].append(where_query)
         return self
 
@@ -184,13 +185,24 @@ class MySQLStatements[T: Table, *Ts](AbstractSQLStatements[T, *Ts, MySQLConnecti
         return func.Sum[T](self._model, column=column, alias=alias, alias_name=alias_name)
 
     @override
-    def join[*FKTables](self, joins) -> IStatements_two_generic[T, *FKTables, MySQLConnection]:
-        if not isinstance(joins[0], tuple):
-            joins = (joins,)
+    def join[*FKTables](
+        self,
+        table: Optional[T] = None,
+        relation: Optional[WhereCondition[T, *FKTables]] = None,
+        join_type: Optional[JoinType] = None,
+    ) -> IStatements_two_generic[T, *FKTables, MySQLConnection]:
+        if isinstance(table, type) and issubclass(table, Table):
+            joins = ((table, relation, join_type),)
+        else:
+            if any(len(x) != 3 for x in table):
+                raise ValueError("Each tuple inside of 'join' method must contain the referenced table, relation between columns and join type")
+            joins = table
+
         new_tables: list[Type[Table]] = [self._model]
-        for table, where in joins:
+
+        for table, where, by in joins:
             new_tables.append(table)
-            join_query = JoinSelector[T, type(table)](self._model, table, by=JoinType.INNER_JOIN, where=where)
+            join_query = JoinSelector[T, type(table)](self._model, table, by=by, where=where)
             self._query_list["join"].append(join_query)
         self._models = new_tables
         return self
@@ -217,7 +229,7 @@ class MySQLStatements[T: Table, *Ts](AbstractSQLStatements[T, *Ts, MySQLConnecti
         self._query_list["select"].append(select)
 
         self._query: str = self._build()
-        
+
         if flavour:
             result = self._return_flavour(self.query, flavour, select, **kwargs)
             if issubclass(flavour, tuple) and isinstance(selector(*self._models), property):
@@ -252,6 +264,10 @@ class MySQLStatements[T: Table, *Ts](AbstractSQLStatements[T, *Ts, MySQLConnecti
         self._query_list["group by"].append(groupby)
         return self
 
+    @override
+    def alias(self, column: Callable[[T, *Ts], Any], alias: str) -> IStatements_two_generic[T, *Ts, MySQLConnection]:
+        return Alias[T, *Ts](self.models, column, alias_name=alias)
+
     @override
     @clear_list
     def _build(self) -> str:

{ormlambda-2.9.4.dist-info → ormlambda-2.11.1.dist-info}/METADATA

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

@@ -2,21 +2,21 @@ ormlambda/__init__.py,sha256=lWQxjf2cQ2bXenNaDpoy2Bar6imiPlzc4nK0hkIYhC0,723
 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=xmpr7_Hn5r1bRG2UtOKdhlZgXUqgFGuTTXsmm4LqmEI,5100
-ormlambda/common/abstract_classes/decomposition_query.py,sha256=vX4H-QLGo7mEuDgyXuKSd_1RySywN3fSislrmU4M-No,13791
+ormlambda/common/abstract_classes/decomposition_query.py,sha256=rXy4dNU51_JDAtZRl0X6LYlfRHG0TtFnUJ_mEgvb2cU,14944
 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/errors/__init__.py,sha256=cWFOYuAauXxzYyGKVP97Uy0EIim5D8ewoTyK-hXkonY,184
+ormlambda/common/errors/__init__.py,sha256=lUwrezLE5xhs2TuGYghtLTKd_YTyo7aOZQCtccuhcYs,486
 ormlambda/common/interfaces/IAggregate.py,sha256=i9zZIYrstP2oolUYqR-udeQQl7M0NwSzrr-VUL0b5HI,271
-ormlambda/common/interfaces/ICustomAlias.py,sha256=_4r8ew9trUY_DJWdYUZXhJCe_I62HUr7ZdsmW6Ln98M,121
-ormlambda/common/interfaces/IDecompositionQuery.py,sha256=7B4cnbJbyESk8GltS1A8wCXr56T_6kZJNIij66CcvPA,1447
+ormlambda/common/interfaces/ICustomAlias.py,sha256=OuNMScDBrYNriRxViPHdyCk1ZTUpFyMKQEm8AWNDqmA,123
+ormlambda/common/interfaces/IDecompositionQuery.py,sha256=XE7xqWaZSuopYQXMw_3pOmsbLnUiEbZ_DQ0ykVx823M,1471
 ormlambda/common/interfaces/INonQueryCommand.py,sha256=7CjLW4sKqkR5zUIGvhRXOtzTs6vypJW1a9EJHlgCw2c,260
 ormlambda/common/interfaces/IQueryCommand.py,sha256=hfzCosK4-n8RJIb2PYs8b0qU3TNmfYluZXBf47KxxKs,331
 ormlambda/common/interfaces/IRepositoryBase.py,sha256=M4pD4t6tXo5WaRhwu2vsza1FoAj2S-rEJKjPfKeSRn0,1134
-ormlambda/common/interfaces/IStatements.py,sha256=RQpOy3REjRf9SV9kDo0ohEzfkzkVBxD_gSiM-Dii5-Y,12821
-ormlambda/common/interfaces/__init__.py,sha256=00ca9a-u_A8DzyEyxPfBMxfqLKFzzUgJaeNmoRitAbA,360
+ormlambda/common/interfaces/IStatements.py,sha256=Y8EvTDGSKYgingWbufonwW4F0IEjXGM7HKCFdszmdC8,13291
+ormlambda/common/interfaces/__init__.py,sha256=miEhv242PB6b-XoB_RCavv8ADdrR-3WYHmDQVubcQzk,459
 ormlambda/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ormlambda/components/delete/IDelete.py,sha256=06ZEdbKBxsHSwsGMBu0E1om4WJjojZAm-L3b95eQrcc,139
 ormlambda/components/delete/__init__.py,sha256=X_at2L4QkxDVK1olXhFHqNemkB8Dxbb7BYqv0EJyu7M,102
@@ -34,8 +34,8 @@ 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=F7p---sNQBefi_dgydV6Wp1YuOwDzvSQOdbcjWtBi2k,767
-ormlambda/databases/my_sql/clauses/alias.py,sha256=yRBEJ1IlL7j8ZozjR-4jtQNkJZDweu-1VNLJEOyA4o8,887
+ormlambda/databases/my_sql/clauses/__init__.py,sha256=nBK8DtmuDUJax1kE-QfMiHlm9m6bueyYMjH5YMmpdk4,801
+ormlambda/databases/my_sql/clauses/alias.py,sha256=nCOCQtqYfs3KVjeX6rIOOqMa7dVeVjfxUxVhAghc6g4,889
 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
@@ -50,14 +50,14 @@ ormlambda/databases/my_sql/clauses/order.py,sha256=XTMtR5ObAJxq8eTHp392rykQD991e
 ormlambda/databases/my_sql/clauses/select.py,sha256=q-rJWbYtfgKEGf-OOH3ToGY90KXGzH3FnKHTc0xsAbM,1962
 ormlambda/databases/my_sql/clauses/update.py,sha256=d2nSLiGe8OUk0ASgGxchit_1DL-Yg8U-DUtBbgpfkto,1571
 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/clauses/where_condition.py,sha256=-yVdQEN-q21Fev3_Gc08m00TCHehUYuqD6v4U2AGU7M,8522
 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/max.py,sha256=zrO_RBKsHhyokEmSpPI6Yg5OY6Jf4GGp2RveBJdOuuA,1190
 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=6qrP-JC4tvUxin3ixGKBeuqvU9cl9mkjNCdwjWZQA9Y,9059
-ormlambda/databases/my_sql/statements.py,sha256=h7tcyCnGaT2nvWyGhfepLTfgn8bMi5f_Bi_09jOfZm4,12455
+ormlambda/databases/my_sql/statements.py,sha256=7NZM8G60RqB2kd5r1nz8yZmYSz-HWZx-LypaS6rjg8w,13093
 ormlambda/model_base.py,sha256=_UGTnin-yUi9ecT-28YY6TniIPdrje-jMFD3QXyZD6c,1243
 ormlambda/utils/__init__.py,sha256=ywMdWqmA2jHj19-W-S04yfaYF5hv4IZ1lZDq0B8Jnjs,142
 ormlambda/utils/column.py,sha256=SqbX8N63_RwXNrMXuVMOpatDw--aLc47o3kG1sEXhNs,3413
@@ -75,7 +75,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=ch1geCSJIQnnv_D_uzfYk6do533kjtZyeCIh2t0_dkU,10863
-ormlambda-2.9.4.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
-ormlambda-2.9.4.dist-info/METADATA,sha256=URSNrN9Sg-EsXEJ-XI7iBDBXmB-V7rTCX1jvysybIb8,8461
-ormlambda-2.9.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ormlambda-2.9.4.dist-info/RECORD,,
+ormlambda-2.11.1.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
+ormlambda-2.11.1.dist-info/METADATA,sha256=f_U8kqhXJw36LHdcidqWfxxeUGaudtV9O9tJ8jmJaXE,8462
+ormlambda-2.11.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ormlambda-2.11.1.dist-info/RECORD,,