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

ormlambda/common/abstract_classes/abstract_model.py

@@ -1,14 +1,17 @@
 from __future__ import annotations
 from typing import Any, Type, override, Iterable, Literal, TYPE_CHECKING
 from collections import defaultdict
+import abc
 
 
 from ormlambda.utils import Table
 from ormlambda.common.interfaces import IQuery, IRepositoryBase, IStatements_two_generic
+from ormlambda.common.interfaces.IAggregate import IAggregate
 
 if TYPE_CHECKING:
+    from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
     from ormlambda.components.select import ISelect
-    from ormlambda.components.select import TableColumn
+    from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
 
 
 ORDER_QUERIES = Literal["select", "join", "where", "order", "with", "group by", "limit", "offset"]
@@ -50,33 +53,45 @@ class AbstractSQLStatements[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
         response_sql = self._repository.read_sql(query, flavour=dict)  # store all columns of the SQL query
 
         if isinstance(response_sql, Iterable):
-            return ClusterQuery(select, response_sql).clean_response()
+            return ClusterQuery[T](select, response_sql).clean_response()
 
         return response_sql
 
+    @abc.abstractmethod
+    def _build(sef): ...
 
-class ClusterQuery:
-    def __init__(self, select: ISelect, response_sql: tuple[dict[str, Any]]) -> None:
-        self._select: ISelect = select
+
+class ClusterQuery[T]:
+    def __init__(self, select: DecompositionQueryBase[T], response_sql: tuple[dict[str, Any]]) -> None:
+        self._select: DecompositionQueryBase[T] = select
         self._response_sql: tuple[dict[str, Any]] = response_sql
 
     def loop_foo(self) -> dict[Type[Table], list[Table]]:
         #  We must ensure to get the valid attributes for each instance
         table_initialize = defaultdict(list)
 
-        unic_table: dict[Table, list[TableColumn]] = defaultdict(list)
-        for table_col in self._select.select_list:
-            unic_table[table_col._table].append(table_col)
-
-        for table_, table_col in unic_table.items():
+        for table, clauses in self._select._clauses_group_by_tables.items():
             for dicc_cols in self._response_sql:
                 valid_attr: dict[str, Any] = {}
-                for col in table_col:
-                    valid_attr[col.real_column] = dicc_cols[col.alias]
+                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")
+                    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
-                table_initialize[table_].append(table_(**valid_attr))
+                table_initialize[table].append(table(**valid_attr))
         return table_initialize
 
+    def get_all_aggregate_method(self, clauses: list[ClauseInfo]) -> str:
+        res: set[str] = set()
+
+        for clause in clauses:
+            row = clause._row_column
+            if isinstance(row, IAggregate):
+                res.add(row.__class__.__name__)
+        return ", ".join(res)
+
     def clean_response(self) -> tuple[dict[Type[Table], tuple[Table]]]:
         tbl_dicc: dict[Type[Table], list[Table]] = self.loop_foo()
 

ormlambda/common/abstract_classes/decomposition_query.py

@@ -0,0 +1,301 @@
+from __future__ import annotations
+from collections import defaultdict
+import typing as tp
+import inspect
+import abc
+from ormlambda import Table
+
+from ormlambda.utils.lambda_disassembler.tree_instruction import TreeInstruction
+from ormlambda.common.interfaces import IAggregate, IDecompositionQuery
+from ormlambda import JoinType, ForeignKey
+from ormlambda.databases.my_sql.clauses.joins import JoinSelector
+from ormlambda.utils.module_tree.dfs_traversal import DFSTraversal
+
+ClauseDataType = tp.TypeVar("ClauseDataType", bound=tp.Union[property, str])
+
+
+class ClauseInfo[T: tp.Type[Table]]:
+    @tp.overload
+    def __init__(self, table: T, column: property, alias_children_resolver: tp.Callable[..., str]): ...
+    @tp.overload
+    def __init__(self, table: T, column: str, alias_children_resolver: tp.Callable[..., str]): ...
+
+    def __init__(self, table: T, column: ClauseDataType, alias_children_resolver: tp.Callable[[DecompositionQueryBase[T], str], str]):
+        self._table: T = table
+        self._row_column: ClauseDataType = column
+        self._column: str = self._resolve_column(column)
+        self._alias_children_resolver: tp.Callable[[DecompositionQueryBase[T], str], str] = alias_children_resolver
+        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}"
+
+    @property
+    def column(self) -> ClauseDataType:
+        return self._column
+
+    @property
+    def alias(self) -> str:
+        return self._alias
+
+    @property
+    def query(self) -> str:
+        return self._query
+
+    def _resolve_column(self, data: ClauseDataType) -> str:
+        if isinstance(data, property):
+            return self._table.__properties_mapped__[data]
+
+        elif isinstance(data, IAggregate):
+            return data.alias_name
+
+        elif isinstance(data, str):
+            # TODOL: refactor to base the condition in dict with '*' as key. '*' must to work as special character
+            return f"'{data}'" if data != "*" else data
+
+    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}")
+
+        if isinstance(self._row_column, IAggregate):
+            return self.concat_with_alias(self._row_column.query)
+
+        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:
+            return column_name
+        return f"{column_name} as `{alias}`"
+
+
+class DecompositionQueryBase[T: tp.Type[Table]](IDecompositionQuery[T]):
+    def __init__[*Ts](
+        self,
+        table: T,
+        lambda_query: tp.Callable[[T], tuple[*Ts]],
+        *,
+        alias: bool = True,
+        alias_name: tp.Optional[str] = None,
+        by: JoinType = JoinType.INNER_JOIN,
+        replace_asterisk_char: bool = True,
+    ) -> None:
+        self._table: T = table
+        self._lambda_query: tp.Callable[[T], tuple[Ts]] = lambda_query
+        self._alias: bool = alias
+        self._alias_name: tp.Optional[str] = alias_name
+        self._by: JoinType = by
+
+        self._fk_relationship: set[tuple[tp.Type[Table], tp.Type[Table]]] = set()
+        self._clauses_group_by_tables: dict[tp.Type[Table], list[ClauseInfo[T]]] = defaultdict(list)
+        self._all_clauses: list[ClauseInfo] = []
+        self.alias_cache: dict[str, tp.Any] = {"*": lambda x: x}
+        self._replace_asterisk_char: bool = replace_asterisk_char
+        self.__assign_lambda_variables_to_table(lambda_query)
+
+        self.__clauses_list_generetor(lambda_query)
+
+    def alias_children_resolver[Tclause: tp.Type[Table]](self, clause_info: ClauseInfo[Tclause]):
+        DEFAULT_ALIAS: str = f"{clause_info._table.__table_name__}_{clause_info._column}"
+
+        if isinstance(clause_info._row_column, IAggregate):
+            return clause_info._row_column.alias_name
+        return DEFAULT_ALIAS
+
+    def __assign_lambda_variables_to_table(self, _lambda: tp.Callable[[T], None]) -> None:
+        """
+        return a dictionary with the lambda's parameters as keys and Type[Table] as the values
+
+
+        >>> res = _assign_lambda_variables_to_table(lambda a,ci,co: ...)
+        >>> print(res)
+        >>> # {
+        >>> #   "a": Address,
+        >>> #   "ci": City,
+        >>> #   "co": Country,
+        >>> # }
+        """
+        lambda_vars = tuple(inspect.signature(_lambda).parameters)
+
+        for param in lambda_vars:
+            self.alias_cache[param] = lambda x: self._table
+        return None
+
+    def __clauses_list_generetor(self, function: tp.Callable[[T], tp.Any]) -> None:
+        if not callable(function):
+            return None
+
+        resolved_function = function(self._table)
+
+        # 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 index, value in enumerate(resolved_function):
+            values: ClauseInfo | list[ClauseInfo] = self._identify_value_type(index, value, function)
+
+            if isinstance(values, tp.Iterable):
+                [self.add_clause(x) for x in values]
+            else:
+                self.add_clause(values)
+
+        return None
+
+    def _identify_value_type[TProp](self, index: int, value: TProp, function) -> ClauseInfo[T]:
+        """
+        A method that behaves based on the variable's type
+        """
+        if isinstance(value, property):
+            if value in self._table.__properties_mapped__:
+                return ClauseInfo[T](self._table, value, self.alias_children_resolver)
+
+            return self._search_correct_table_for_prop(index, function, value)
+
+        elif isinstance(value, IAggregate):
+            return ClauseInfo[T](self._table, value, self.alias_children_resolver)
+
+        # if value is a Table instance (when you need to retrieve all columns) we'll ensure that all INNER JOINs are added
+        elif isinstance(value, type) and issubclass(value, Table):
+            if self._table != value:
+                self._add_necessary_fk(index, function, value)
+            # all columns
+            clauses: list[ClauseInfo] = []
+            for prop in value.__properties_mapped__:
+                if isinstance(prop, property):
+                    clauses.append(self._identify_value_type(index, prop, function))
+            return clauses
+
+        elif isinstance(value, str):
+            # TODOM: alias_cache to replace '*' by all columns
+            if self._replace_asterisk_char and (replace_value := self.alias_cache.get(value, None)) is not None:
+                return self._identify_value_type(index, replace_value(self._table), function)
+            return ClauseInfo[T](self._table, value, alias_children_resolver=self.alias_children_resolver)
+
+        elif isinstance(value, bool):
+            ...
+
+        raise NotImplementedError(f"type of value '{value}' is not implemented.")
+
+    def _search_correct_table_for_prop[TTable](self, index: int, function: tp.Callable[[T], tp.Any], prop: property) -> ClauseInfo[TTable]:
+        tree_list = TreeInstruction(function).to_list()
+        temp_table: tp.Type[Table] = self._table
+
+        table_list: list[Table] = tree_list[index].nested_element.parents[1:]
+        counter: int = 0
+        while prop not in temp_table.__properties_mapped__:
+            new_table: TTable = getattr(temp_table(), table_list[counter])
+
+            if not isinstance(new_table, type) or not issubclass(new_table, Table):
+                raise ValueError(f"new_table var must be '{Table.__class__}' type and is '{type(new_table)}'")
+            self.__add_fk_relationship(temp_table, new_table)
+
+            temp_table = new_table
+            counter += 1
+
+            if prop in new_table.__properties_mapped__:
+                return ClauseInfo[TTable](new_table, prop, self.alias_children_resolver)
+
+        raise ValueError(f"property '{prop}' does not exist in any inherit table.")
+
+    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)
+
+        return None
+
+    def _add_necessary_fk(self, index: int, function: tp.Callable[[T], tp.Any], table: tp.Type[Table]) -> None:
+        tree_list = TreeInstruction(function).to_list()
+        old_table: tp.Type[Table] = self._table
+
+        table_list: list[Table] = tree_list[index].nested_element.parents[1:]
+        counter: int = 0
+        while table not in old_table.__dict__.values():
+            new_table: tp.Type[Table] = getattr(old_table(), table_list[counter])
+
+            if not issubclass(new_table, Table):
+                raise ValueError(f"new_table var must be '{Table.__class__}' type and is '{type(new_table)}'")
+
+            self.__add_fk_relationship(old_table, new_table)
+
+            if table in new_table.__dict__.values():
+                self.__add_fk_relationship(new_table, table)
+                return None
+
+            old_table = new_table
+            counter += 1
+
+        self.__add_fk_relationship(old_table, table)
+        return None
+
+    @property
+    def table(self) -> T:
+        return self._table
+
+    @property
+    def lambda_query[*Ts](self) -> tp.Callable[[T], tuple[*Ts]]:
+        return self._lambda_query
+
+    @property
+    def all_clauses(self) -> list[ClauseInfo[T]]:
+        return self._all_clauses
+
+    @property
+    def clauses_group_by_tables(self) -> dict[tp.Type[Table], list[ClauseInfo[T]]]:
+        return self._clauses_group_by_tables
+
+    @property
+    def has_foreign_keys(self) -> bool:
+        return len(self._fk_relationship) > 0
+
+    @property
+    def fk_relationship(self) -> set[tuple[tp.Type[Table], tp.Type[Table]]]:
+        return self._fk_relationship
+
+    @property
+    @abc.abstractmethod
+    def query(self) -> str: ...
+
+    @property
+    def alias(self) -> str:
+        return self._alias
+
+    @property
+    def alias_name(self) -> str:
+        return self._alias_name
+
+    @alias_name.setter
+    def alias_name(self, value: tp.Optional[str]) -> None:
+        if value is None and self._alias:
+            self._alias = False
+        else:
+            self._alias = True
+
+        self._alias_name = value
+
+    def stringify_foreign_key(self, sep: str = "\n") -> str:
+        graph: dict[tp.Type[Table], list[tp.Type[Table]]] = defaultdict(list)
+        for left, right in self.fk_relationship:
+            graph[left].append(right)
+
+        dfs = DFSTraversal.sort(graph)[::-1]
+        query: list = []
+        for l_tbl in dfs:
+            list_r_tbl = graph[l_tbl]
+            if not list_r_tbl:
+                continue
+
+            for r_tbl in list_r_tbl:
+                lambda_relationship = ForeignKey.MAPPED[l_tbl.__table_name__].referenced_tables[r_tbl.__table_name__].relationship
+
+                join = JoinSelector(l_tbl, r_tbl, by=self._by, where=lambda_relationship)
+                query.append(join.query)
+
+        return f"{sep}".join(query)
+
+    def __add_fk_relationship(self, t1: Table, t2: Table) -> None:
+        self._fk_relationship.add((t1, t2))
+        return None

ormlambda/common/interfaces/IAggregate.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+import typing as tp
+
+if tp.TYPE_CHECKING:
+    from ormlambda import Table
+from .IQueryCommand import IQuery
+from .IDecompositionQuery import IDecompositionQuery
+
+
+class IAggregate[T: tp.Type[Table]](IDecompositionQuery[T], IQuery): ...

ormlambda/common/interfaces/IDecompositionQuery.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+import abc
+import typing as tp
+
+
+if tp.TYPE_CHECKING:
+    from ormlambda import Table
+
+    # TODOH: Changed to avoid mysql dependency
+    from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
+
+from .IQueryCommand import IQuery
+
+
+class IDecompositionQuery[T: tp.Type[Table]](IQuery):
+    @property
+    @abc.abstractmethod
+    def table(self) -> T: ...
+
+    @property
+    @abc.abstractmethod
+    def lambda_query[*Ts](self) -> tp.Callable[[T], tuple[*Ts]]: ...
+
+    @property
+    @abc.abstractmethod
+    def all_clauses(self) -> list[ClauseInfo]: ...
+
+    @property
+    @abc.abstractmethod
+    def clauses_group_by_tables(self) -> dict[tp.Type[Table], list[ClauseInfo[T]]]: ...
+
+    @property
+    @abc.abstractmethod
+    def fk_relationship(self) -> tuple[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]: ...
+
+    @property
+    @abc.abstractmethod
+    def has_foreign_keys(self) -> bool: ...
+
+    @abc.abstractmethod
+    def stringify_foreign_key(self, sep: str = "\n"): ...
+
+    @abc.abstractmethod
+    def alias_children_resolver(self) -> tp.Callable[[tp.Type[Table], str], str]: ...

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]: ...
 

ormlambda/common/interfaces/IStatements.py

@@ -91,7 +91,7 @@ class IStatements[T: Table](ABC):
 
     # region count
     @abstractmethod
-    def count(self) -> int: ...
+    def count(self, selection: Callable[[T], property]) -> int: ...
 
     # endregion
 
@@ -235,8 +235,14 @@ class IStatements[T: Table](ABC):
 
     # endregion
 
+    # region group_by
     @abstractmethod
-    def build(self) -> str: ...
+    def group_by[TRepo, *Ts](self, column: Callable[[T], TRepo], select_query: Callable[[T], tuple[*Ts]]) -> tuple[tuple[*Ts]]: ...
+
+    # endregion
+
+    @abstractmethod
+    def _build(self) -> str: ...
 
 
 class IStatements_two_generic[T: Table, TRepo](IStatements[T]):

ormlambda/common/interfaces/__init__.py

@@ -2,3 +2,5 @@ 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

ormlambda/databases/my_sql/clauses/__init__.py

@@ -1,14 +1,16 @@
-from .create_database import CreateDatabase, TypeExists  # noqa: F401
-from .delete import DeleteQuery  # noqa: F401
-from .drop_database import DropDatabase  # noqa: F401
-from .drop_table import DropTable  # noqa: F401
-from .insert import InsertQuery  # noqa: F401
-from .joins import JoinSelector, JoinType  # noqa: F401
-from .limit import LimitQuery  # noqa: F401
-from .offset import OffsetQuery  # noqa: F401
-from .order import OrderQuery  # noqa: F401
-from .select import SelectQuery  # noqa: F401
-from .update import UpdateQuery  # noqa: F401
-from .upsert import UpsertQuery  # noqa: F401
-from .where_condition import WhereCondition  # noqa: F401
-from .count import CountQuery  # noqa: F401
+from .create_database import CreateDatabase as CreateDatabase
+from .create_database import TypeExists as TypeExists
+from .delete import DeleteQuery as DeleteQuery
+from .drop_database import DropDatabase as DropDatabase
+from .drop_table import DropTable as DropTable
+from .insert import InsertQuery as InsertQuery
+from .joins import JoinSelector as JoinSelector
+from .joins import JoinType as JoinType
+from .limit import LimitQuery as LimitQuery
+from .offset import OffsetQuery as OffsetQuery
+from .order import OrderQuery as OrderQuery
+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

ormlambda/databases/my_sql/clauses/count.py

@@ -1,35 +1,39 @@
-from typing import Callable, Type, override
+import typing as tp
 
-from ormlambda import Table, JoinType, ForeignKey
-from ormlambda.databases.my_sql.clauses.joins import JoinSelector
-from ormlambda.databases.my_sql.clauses.select import SelectQuery
+if tp.TYPE_CHECKING:
+    from ormlambda import Table
+from ormlambda.common.interfaces import IAggregate
+from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase, ClauseInfo
+from ormlambda import JoinType
 
 
-class CountQuery[T: Type[Table]](SelectQuery[T]):
-    CLAUSE: str = "COUNT"
+class Count[T: tp.Type[Table]](DecompositionQueryBase[T], IAggregate[T]):
+    NAME: str = "COUNT"
 
     def __init__(
         self,
-        tables: T | tuple[T] = (),
-        select_lambda: Callable[[T], None] | None = lambda: None,
+        table: T,
+        lambda_query: str | tp.Callable[[T], tuple],
         *,
+        alias: bool = True,
+        alias_name: str = "count",
         by: JoinType = JoinType.INNER_JOIN,
     ) -> None:
-        super().__init__(tables, select_lambda, by=by)
+        super().__init__(
+            table,
+            lambda_query=lambda_query,
+            alias=alias,
+            alias_name=alias_name,
+            by=by,
+            replace_asterisk_char=False,
+        )
+
+    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
 
-    @override
     @property
     def query(self) -> str:
-        query: str = f"{self.SELECT} {self.CLAUSE}(*) FROM {self._first_table.__table_name__}"
-
-        involved_tables = self.get_involved_tables()
-        if not involved_tables:
-            return query
-
-        sub_query: str = ""
-        for l_tbl, r_tbl in involved_tables:
-            join = JoinSelector(l_tbl, r_tbl, by=self._by, where=ForeignKey.MAPPED[l_tbl.__table_name__].referenced_tables[r_tbl.__table_name__].relationship)
-            sub_query += f" {join.query}"
-
-        query += sub_query
-        return query
+        col = ", ".join([x.query for x in self.all_clauses])
+        return f"{self.NAME}({col})"