ormlambda 3.35.2__py3-none-any.whl → 4.0.0__py3-none-any.whl

ormlambda/sql/functions/min.py

@@ -1,39 +1,24 @@
 from __future__ import annotations
-import typing as tp
 
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
-from ormlambda.sql.clause_info import ClauseInfo
+from ormlambda.sql.elements import ClauseElement
 from ormlambda.sql.types import ColumnType, AliasType
-from ormlambda.sql.clause_info import AggregateFunctionBase
+from ormlambda.sql.clause_info import IAggregate
 
-if tp.TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
 
-
-class Min(AggregateFunctionBase):
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "MIN"
+class Min(ClauseElement, IAggregate):
+    __visit_name__ = "min"
 
     def __init__[TProp](
         self,
-        elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
-        alias_clause: AliasType[ColumnType[TProp]] = "min",
-        context: ClauseContextType = None,
-        *,
-        dialect: Dialect,
+        elements: ColumnType[TProp],
+        alias: AliasType[ColumnType[TProp]] = "min",
     ):
-        super().__init__(table=None, column=elements, alias_table=None, alias_clause=alias_clause, context=context, keep_asterisk=False, preserve_context=False, dialect=dialect)
-
-    @tp.override
-    def query(self, dialect: Dialect, **kwargs) -> str:
-        columns: list[str] = []
+        self.column = elements
+        self.alias = alias
 
-        context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
-        for clause in self._convert_into_clauseInfo(self.unresolved_column, context, dialect=self._dialect):
-            new_clause = clause
-            new_clause.alias_clause = None
-            columns.append(new_clause)
+    def used_columns(self):
+        return [self.column]
 
-        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns,dialect=self._dialect)})"
-        return self._concat_alias_and_column(method_string, self._alias_aggregate)
+    @property
+    def dtype(self) -> int:
+        return int

ormlambda/sql/functions/sum.py

@@ -1,41 +1,25 @@
 from __future__ import annotations
-import typing as tp
 
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
-from ormlambda.sql.clause_info import ClauseInfo
-from ormlambda.sql.types import ColumnType, AliasType
-from ormlambda.sql.clause_info import AggregateFunctionBase
-
-if tp.TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
+from ormlambda.sql.elements import ClauseElement
 
+from ormlambda.sql.types import ColumnType, AliasType
+from ormlambda.sql.clause_info import IAggregate
 
-class Sum(AggregateFunctionBase):
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "SUM"
 
-    def __init__[TProp](self, elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp], alias_clause: AliasType[ColumnType[TProp]] = "sum", context: ClauseContextType = None, *, dialect: Dialect):
-        super().__init__(
-            table=None,
-            column=elements,
-            alias_table=None,
-            alias_clause=alias_clause,
-            context=context,
-            keep_asterisk=False,
-            preserve_context=False,
-            dialect=dialect,
-        )
+class Sum(ClauseElement, IAggregate):
+    __visit_name__ = "sum"
 
-    @tp.override
-    def query(self, dialect: Dialect, **kwargs) -> str:
-        columns: list[str] = []
+    def __init__[TProp](
+        self,
+        elements: ColumnType[TProp],
+        alias: AliasType[ColumnType[TProp]] = "sum",
+    ):
+        self.column = elements
+        self.alias = alias
 
-        context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
-        for clause in self._convert_into_clauseInfo(self.unresolved_column, context, self._dialect):
-            new_clause = clause
-            new_clause.alias_clause = None
-            columns.append(new_clause)
+    def used_columns(self):
+        return [self.column]
 
-        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns,dialect=self._dialect)})"
-        return self._concat_alias_and_column(method_string, self._alias_aggregate)
+    @property
+    def dtype(self) -> int:
+        return int

ormlambda/sql/sqltypes.py

@@ -651,6 +651,8 @@ _type_dicc: dict[Any, TypeEngine[Any]] = {
 
 
 def resolve_primitive_types[T](value: T) -> TypeEngine[T]:
+    if issubclass(value, TypeEngine):
+        return value()
     if inspect.isclass(value):
         type_ = _type_dicc.get(value, None)
 

ormlambda/sql/table/__init__.py

@@ -1 +1,2 @@
 from .table import Table, TableMeta  # noqa: F401
+from .table_proxy import TableProxy  # noqa: F401

ormlambda/sql/table/table.py

@@ -2,14 +2,13 @@ from __future__ import annotations
 from typing import Any, Optional, Type, dataclass_transform, TYPE_CHECKING
 import json
 
-from ormlambda.sql import Column
-from ormlambda.sql import ForeignKey
-from ormlambda.util.module_tree.dfs_traversal import DFSTraversal
-from ormlambda.sql.ddl import CreateTable
+from ormlambda.sql.ddl import CreateTable, DropTable
+from ormlambda import util
 
 if TYPE_CHECKING:
-    from ormlambda.statements import BaseStatement
+    from ormlambda.sql import Column
     from ormlambda.dialects import Dialect
+    from ormlambda import ForeignKey
 
 from .table_constructor import __init_constructor__
 
@@ -33,6 +32,7 @@ class TableMeta(type):
             raise Exception(f"class variable '__table_name__' of '{cls_object.__name__}' class must be 'str'")
 
         self = __init_constructor__(cls_object)
+
         return self
 
     def __repr__(cls: "Table") -> str:
@@ -84,7 +84,7 @@ class Table(metaclass=TableMeta):
 
         dicc: dict[str, str] = {x: str(getattr(self, x)) for x in self.__annotations__}
         equal_loop = ["=".join((x, __cast_long_variables(y))) for x, y in dicc.items()]
-        return f'{self.__class__.__name__}({", ".join(equal_loop)})'
+        return f"{self.__class__.__name__}({', '.join(equal_loop)})"
 
     def __getitem__[TProp](self, value: str | Column[TProp]) -> Optional[TProp]:
         name = value if isinstance(value, str) else value.column_name
@@ -93,25 +93,40 @@ class Table(metaclass=TableMeta):
         return None
 
     def to_dict(self) -> dict[str, str | int]:
+        def make_hashable(item: Any) -> Any:
+            if isinstance(item, dict):
+                return tuple(sorted((k, make_hashable(x)) for k, x in item.items()))
+
+            if isinstance(item, (list | set)):
+                return tuple(make_hashable(x) for x in item)
+            if hasattr(item, "__iter__") and not isinstance(item, str | bytes):
+                try:
+                    return tuple(make_hashable(x) for x in item)
+                except TypeError:
+                    return item  # if it fails, it's already hashable
+            return item
+
         dicc: dict[str, Any] = {}
         for x in self.__annotations__:
             value = getattr(self, x)
-            if isinstance(value, dict):
-                value = tuple(sorted(value.items()))
-            if isinstance(value, list | set):
-                value = tuple(value)
-            dicc[x] = value
+            dicc[x] = make_hashable(value)
         return dicc
 
+    @util.preload_module("ormlambda.sql")
     @classmethod
     def get_pk(cls) -> Optional[Column]:
+        Column = util.preloaded.sql_column.Column
+        ColumnProxy = util.preloaded.sql_column.ColumnProxy
         for obj in cls.__dict__.values():
-            if isinstance(obj, Column) and obj.is_primary_key:
+            if isinstance(obj, Column | ColumnProxy) and obj.is_primary_key:
                 return obj
         return None
 
+    @util.preload_module("ormlambda.sql")
     @classmethod
     def get_columns(cls) -> tuple[Column, ...]:
+        Column = util.preloaded.sql_column.Column
+
         return tuple([x for x in cls.__annotations__.values() if isinstance(x, Column)])
 
     @classmethod
@@ -120,48 +135,13 @@ class Table(metaclass=TableMeta):
             if name == key:
                 return value
 
-    @classmethod
-    def create_table_query(cls, statement: BaseStatement) -> str:
-        """It's classmethod because of it does not matter the columns values to create the table"""
-        from ormlambda.sql.schema_generator import SchemaGeneratorFactory
-
-        return SchemaGeneratorFactory.get_generator(statement._dialect).create_table(cls)
-
     @classmethod
     def create_table(cls, dialect: Dialect) -> str:
         return CreateTable(cls).compile(dialect).string
 
     @classmethod
-    def find_dependent_tables(cls) -> tuple["Table", ...]:
-        """Work in progress"""
-        return
-
-        # TODOL: Dive into new way to return dependent tables
-        def get_involved_tables(graph: dict[Table, list[Table]], table_name: str) -> None:
-            """
-            Create a graph to be ordered
-            """
-            table = ForeignKey[Table, Table].MAPPED[table_name]
-            for x in table.referenced_tables:
-                if data := ForeignKey.MAPPED.get(x, None):
-                    get_involved_tables(graph, data.table_object.__table_name__)
-
-            graph[table.table_object.__table_name__] = list(table.referenced_tables)
-            return None
-
-        graph: dict[Table, list[Table]] = {}
-        dependent = ForeignKey.MAPPED.get(cls.__table_name__, None)
-        if dependent is None:
-            return tuple([])
-
-        graph[cls.__table_name__] = list(dependent.referenced_tables)
-        get_involved_tables(graph, cls.__table_name__)
-
-        dfs = DFSTraversal.sort(graph)
-
-        order_table = dfs[: dfs.index(cls.__table_name__)]
-
-        return [ForeignKey.MAPPED[x].table_object for x in order_table]
+    def drop_table(cls, dialect: Dialect) -> str:
+        return DropTable(cls).compile(dialect).string
 
     def __eq__(self, __value: Any) -> bool:
         return hash(self) == hash(__value)
@@ -175,6 +155,9 @@ class Table(metaclass=TableMeta):
             return f"`{cls.__table_name__}_{column}`"
         return cls.__table_name__
 
+    @util.preload_module("ormlambda.sql")
     @classmethod
     def foreign_keys(cls) -> dict[str, ForeignKey]:
+        ForeignKey = util.preloaded.sql_foreign_key.ForeignKey
+
         return {key: value for key, value in cls.__dict__.items() if isinstance(value, ForeignKey)}

ormlambda/sql/table/table_proxy.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Any, Type
+
+from ormlambda.sql.column_table_proxy import ColumnTableProxy
+from ormlambda.sql.elements import ClauseElement
+from ormlambda.sql.context import FKChain
+
+from ormlambda import util
+
+if TYPE_CHECKING:
+    from ormlambda import Table
+    from ormlambda import ForeignKey
+
+
+type CurrentPathType = Optional[FKChain]
+type ForeignKeyRegistryType = dict[str, list[ForeignKey]]
+type PathAliasesType = dict[str, str]
+type QueryMetadataType = dict[str, Any]
+
+
+class TableProxy[T: Table](ColumnTableProxy, ClauseElement):
+    __visit_name__ = "table_proxy"
+    _table_class: Type[Table]
+    _path: FKChain
+
+    def __init__(self, table_class: Type[T], path: Optional[FKChain] = None):
+        if not path:
+            path = FKChain(table_class, [])
+
+        self._table_class = table_class
+        super().__init__(path.copy())
+
+    def __repr__(self) -> str:
+        return f"{TableProxy.__name__}({self._table_class.__table_name__}) Path={self._path.get_path_key()})"
+
+    @util.preload_module(
+        "ormlambda.sql.foreign_key",
+        "ormlambda.sql.column",
+    )
+    def __getattr__(self, name: str):
+        """Intercept attribute access to handle foreign keys and columns"""
+
+        ColumnProxy = util.preloaded.sql_column.ColumnProxy
+        Column = util.preloaded.sql_column.Column
+        ForeignKey = util.preloaded.sql_foreign_key.ForeignKey
+
+        # Get the actual attribute from the table class
+        try:
+            attr = getattr(self._table_class, name)
+        except AttributeError:
+            # If column doesn't exist is because we're dealing with aliases like
+            #  `lambda x: x.count` where 'count' is actually an alias not a column name
+            # we don't want use table name
+            attr = Column(dtype=str)
+            attr.column_name = name
+            return ColumnProxy(attr, path=FKChain(None, []))
+
+        if isinstance(attr, ForeignKey):
+            new_path = self._path.copy()
+            new_path.add_step(attr)
+            return TableProxy(attr.tright, new_path)
+
+        elif isinstance(attr, Column):
+            # Accessing a column - return column reference with path info
+
+            column = ColumnProxy(attr, self._path.copy())
+            self._path.clear()
+            return column
+
+        else:
+            return attr
+
+    def get_alias(self) -> str:
+        """Get the alias for this table based on its path"""
+        return self._path.get_alias()
+
+    def get_table_chain(self):
+        return self.get_alias()
+
+    @util.preload_module("ormlambda.sql.column")
+    def get_columns(self) -> tuple[ColumnTableProxy]:
+        ColumnProxy = util.preloaded.sql_column.ColumnProxy
+
+        result = []
+        for column in self._table_class.get_columns():
+            col_proxy = ColumnProxy(column, self._path)
+            result.append(col_proxy)
+        return result

ormlambda/sql/type_api.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 from typing import Any, ClassVar
 from ormlambda.sql.visitors import Element
+from ormlambda import util
 import abc
 
 
@@ -26,8 +27,10 @@ class TypeEngine[T: Any](Element, abc.ABC):
     def _resolve_for_literal_value(self, value: T) -> TypeEngine[T]:
         return self
 
+    @util.preload_module("ormlambda.sql.sqltypes")
     def coerce_compared_value[TType](self, value: TType) -> TypeEngine[TType]:
-        from .sqltypes import resolve_primitive_types, NULLTYPE
+        resolve_primitive_types = util.preloaded.sql_types.resolve_primitive_types
+        NULLTYPE = util.preloaded.sql_types.NULLTYPE
 
         _coerced_type = resolve_primitive_types(value)
         if _coerced_type is NULLTYPE:

ormlambda/sql/types.py

@@ -1,27 +1,30 @@
-import typing as tp
+from typing import TYPE_CHECKING, Literal, Callable, Type
 
 
-if tp.TYPE_CHECKING:
-    from ormlambda import Table, Column, ForeignKey
+if TYPE_CHECKING:
+    from ormlambda.sql.clause_info import IAggregate
+    from ormlambda import Table
     from ormlambda.sql.comparer import Comparer
     from ormlambda import ConditionType as ConditionEnum
-    from ormlambda.common.enums.join_type import JoinType
+    from ormlambda.common.enums.join_type import JoinType as JoinType
+    from ormlambda import ColumnProxy, TableProxy
 
 
-type AsteriskType = str
-type TableType[T: Table] = tp.Type[T] | ForeignKey[T]
-type ColumnType[TProp] = TProp | Column[TProp] | AsteriskType | tuple[Column]
-type AliasType[T] = tp.Optional[str | tp.Callable[[T], str]]
+type TableType[T: Table] = Type[T] | TableProxy[T]
+type ColumnType[TProp] = TProp | ColumnProxy[TProp]
+type AliasType[TProp] = str | Callable[[ColumnProxy[TProp]], str]
 
 # region Comparer Types
-type ComparerType = tp.Literal["=", "!=", "<", "<=", ">", ">=", "in"]
+type ComparerType = Literal["=", "!=", "<", "<=", ">", ">=", "in"]
 type ConditionType[TProp] = Comparer | ColumnType[TProp]
-type UnionType = tp.Literal["AND", "OR", ""]
+type UnionType = Literal["AND", "OR", ""]
 type ComparerTypes = ComparerType | UnionType | ConditionEnum
+type SelectCol = ColumnProxy | IAggregate | Comparer
 # endregion
 
 type TupleJoinType[T] = tuple[Comparer]
 
-ASTERISK: AsteriskType = "*"
+ASTERISK = "*"
 
-from .compiler import *
+# TODOL []: Look if we can avoid this *
+from .compiler import *  # noqa: F403, E402

ormlambda/statements/__init__.py

@@ -1,3 +1 @@
-from .base_statement import BaseStatement  # noqa: F401
-from .types import OrderType  # noqa: F401
 from .statements import Statements  # noqa: F401

ormlambda/statements/base_statement.py

@@ -1,123 +1,90 @@
 from __future__ import annotations
-from typing import Any, Type, override, Iterable, Literal, TYPE_CHECKING, Optional
+from typing import Any, Type, Iterable, Literal, TYPE_CHECKING
 from collections import defaultdict
 
 
-from ormlambda.repository import BaseRepository
-from ormlambda.statements.interfaces import IStatements_two_generic
 from ormlambda import Table
+from ormlambda import util
 
 from ormlambda.common.errors import AggregateFunctionError
+from ormlambda.sql.clause_info import IAggregate
+
 
 if TYPE_CHECKING:
     from ormlambda.engine.base import Engine
-    from ormlambda.dialects.interface.dialect import Dialect
     from ormlambda.sql.clauses import Select
 
 
 ORDER_QUERIES = Literal["select", "join", "where", "order", "with", "group by", "limit", "offset"]
 
 
-class BaseStatement[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
-    def __init__(self, model: tuple[T, ...], engine: Engine) -> None:
-        self._engine = engine
-        self._dialect = engine.dialect
-        self._query: Optional[str] = None
-        self._model: T = model[0] if isinstance(model, Iterable) else model
-        self._models: tuple[T] = self._model if isinstance(model, Iterable) else (model,)
-
-        repository = engine.repository
-        self.__valid_repository(repository)
-        self._repository: BaseRepository[TRepo] = repository
-
-        if not issubclass(self._model, Table):
-            # Deben heredar de Table ya que es la forma que tenemos para identificar si estamos pasando una instancia del tipo que corresponde o no cuando llamamos a insert o upsert.
-            # Si no heredase de Table no sabriamos identificar el tipo de dato del que se trata porque al llamar a isinstance, obtendriamos el nombre de la clase que mapea a la tabla, Encargo, Edificio, Presupuesto y no podriamos crear una clase generica
-            raise Exception(f"'{model}' class does not inherit from Table class")
-
-    @property
-    def dialect(self) -> Dialect:
-        return self._dialect
-
-    @override
-    def table_exists(self) -> bool:
-        return self._repository.table_exists(self._model.__table_name__)
-
-    @staticmethod
-    def __valid_repository(repository: Any) -> bool:
-        if not isinstance(repository, BaseRepository):
-            raise ValueError(f"'repository' attribute does not instance of '{BaseRepository.__name__}'")
-        return True
-
-    def __repr__(self):
-        return f"<Model: {self.__class__.__name__}>"
-
-    def _return_flavour[TValue](self, query, flavour: Type[TValue], select, **kwargs) -> tuple[TValue]:
-        return self._repository.read_sql(query, flavour=flavour, select=select, **kwargs)
-
-    def _return_model(self, select, query: str) -> tuple[tuple[T]]:
-        response_sql = self._repository.read_sql(query, flavour=dict, select=select)  # store all columns of the SQL query
-        if response_sql and isinstance(response_sql, Iterable):
-            return ClusterResponse(self._dialect, select, response_sql).cluster()
-
-        return response_sql
-
-    @property
-    def query(self) -> str:
-        return self._query
-
-    @property
-    def model(self) -> Type[T]:
-        return self._model
+type ResponseType = Iterable[dict[str, Any]]
 
-    # TODOL: add *Ts when wil be possible
-    @property
-    def models(self) -> tuple:
-        return self._models
 
-    @property
-    def repository(self) -> BaseRepository:
-        return self._repository
-
-
-class ClusterResponse[T]:
-    def __init__(self, dialect: Dialect, select: Select[T], response_sql: tuple[dict[str, Any]]) -> None:
-        self._dialect: Dialect = dialect
+class ClusterResponse[T, TFlavour]:
+    def __init__(self, select: Select[T], engine: Engine, flavour: TFlavour, query: str) -> None:
         self._select: Select[T] = select
-        self._response_sql: tuple[dict[str, Any]] = response_sql
-        self._caster = dialect.caster
+        self.engine = engine
+        self.flavour = flavour
+        self.query = query
 
-    def cluster(self) -> tuple[dict[Type[Table], tuple[Table, ...]]]:
-        tbl_dicc: dict[Type[Table], list[dict[str, Any]]] = self._create_cluster()
+    def cluster(self, response_sql: ResponseType) -> tuple[dict[Type[Table], tuple[Table, ...]]]:
+        tbl_dicc: dict[Type[Table], list[dict[str, Any]]] = self._create_cluster(response_sql)
 
-        response = {}
+        first_table = list(tbl_dicc)[0]
         tuple_response = []
         # it not depend of flavour attr
-        for table, attribute_list in tbl_dicc.items():
+        n_attrs = len(tbl_dicc[first_table])
+        for i in range(n_attrs):
             new_instance = []
-            for attrs in attribute_list:
+            for table in tbl_dicc:
+                attrs = tbl_dicc[table][i]
                 new_instance.append(table(**attrs))
-            response[table] = tuple(new_instance)
             tuple_response.append(tuple(new_instance))
         return tuple(tuple_response)
 
-    def _create_cluster(self) -> dict[Type[Table], list[dict[str, Any]]]:
+    def _create_cluster(self, response_sql: ResponseType) -> dict[Type[Table], list[dict[str, Any]]]:
         # We'll create a default list of dicts *once* we know how many rows are in _response_sql
-        row_count = len(self._response_sql)
+        row_count = len(response_sql)
 
         def make_list_of_dicts() -> list[dict[str, Any]]:
             return [{} for _ in range(row_count)]
 
         table_attr_dict = defaultdict(make_list_of_dicts)
 
-        for i, dicc_cols in enumerate(self._response_sql):
-            for clause in self._select.all_clauses:
-                table = clause.table
-                col = clause.column
-
-                if col is None or not hasattr(table, col):
+        for i, dicc_cols in enumerate(response_sql):
+            for clause in self._select.columns:
+                # if col is None or not hasattr(table, col):
+                if isinstance(clause, IAggregate):
                     raise AggregateFunctionError(clause)
 
-                table_attr_dict[table][i][col] = dicc_cols[clause.alias_clause]
+                table = clause.table
+
+                table_attr_dict[table][i][clause.column_name] = dicc_cols[clause.alias]
         # Convert back to a normal dict if you like (defaultdict is a dict subclass).
         return dict(table_attr_dict)
+
+    @util.preload_module("ormlambda.sql.column")
+    def response(self, **kwargs) -> TFlavour[T, ...]:
+        ColumnProxy = util.preloaded.sql_column.ColumnProxy
+
+        if not self.flavour:
+            return self._return_model()
+
+        result = self._return_flavour(self.flavour, self._select, **kwargs)
+        if issubclass(self.flavour, tuple) and len(self._select.used_columns()) == 1 and isinstance(self._select.used_columns()[0], ColumnProxy):
+            return tuple([x[0] for x in result])
+        return result
+
+    def _return_flavour[TValue](self, flavour: Type[TValue], select, **kwargs) -> tuple[TValue]:
+        return self.engine.repository.read_sql(self.query, flavour=flavour, select=select, **kwargs)
+
+    def _return_model(self) -> tuple[tuple[T]]:
+        response_sql = self.engine.repository.read_sql(self.query, flavour=dict, select=self._select)  # store all columns of the SQL query
+        if response_sql and isinstance(response_sql, Iterable):
+            response = self.cluster(response_sql)
+            if response and len(response[0]) == 1:
+                return tuple([x[0] for x in response])
+            return response
+
+        return response_sql