ormlambda 3.12.2__py3-none-any.whl → 3.34.1__py3-none-any.whl

ormlambda/sql/table/table.py

@@ -0,0 +1,179 @@
+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
+
+if TYPE_CHECKING:
+    from ormlambda.statements import BaseStatement
+    from ormlambda.dialects import Dialect
+
+from .table_constructor import __init_constructor__
+
+
+class TableMeta(type):
+    def __new__[T](cls: "Table", name: str, bases: tuple, dct: dict[str, Any]) -> Type[T]:
+        """
+        That's the class we use to recreate the table's metadata.
+        It's useful because we can dynamically create the __init__ method just by using the type hints of the variables we want to use as column names.
+        We simply call '__init_constructor__' to create all the necessary variables and the method.
+        """
+        cls_object: Table = super().__new__(cls, name, bases, dct)
+
+        if name == "Table":
+            return cls_object
+
+        if cls_object.__table_name__ is Ellipsis:
+            raise Exception(f"class variable '__table_name__' must be declared in '{cls_object.__name__}' class")
+
+        if not isinstance(cls_object.__table_name__, str):
+            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:
+        return f"{TableMeta.__name__}: {cls.__table_name__}"
+
+
+@dataclass_transform(eq_default=False)
+class Table(metaclass=TableMeta):
+    """
+    Class to mapped database tables with Python classes.
+
+    It uses __annotations__ special var to store all table columns. If you do not type class var it means this var is not store as table column
+    and it do not going to appear when you instantiate the object itself.
+
+    This principle it so powerful due to we can create Foreign Key references without break __init__ class method.
+
+    >>> class Address(Table):
+    >>>     __table_name__ = "address"
+
+    >>>     address_id: int = Column(int, is_primary_key=True)
+    >>>     address: str
+    >>>     address2: str
+    >>>     district: str
+    >>>     city_id: int
+    >>>     postal_code: datetime
+    >>>     phone: str
+    >>>     location: datetime
+    >>>     last_update: datetime = Column(datetime, is_auto_generated=True)
+
+    >>>     city = ForeignKey["Address", City](City, lambda a, c: a.city_id == c.city_id)
+    """
+
+    __table_name__: str = ...
+
+    def __str__(self) -> str:
+        params = self.to_dict()
+        return json.dumps(params, ensure_ascii=False, indent=2)
+
+    def __getattr__[T](self, _name: str) -> Column[T]:
+        return self.__dict__.get(_name, None)
+
+    def __repr__(self: "Table") -> str:
+        def __cast_long_variables(value: Any):
+            if not isinstance(value, str):
+                value = str(value)
+            if len(value) > 20:
+                return value[:20] + "..."
+            return value
+
+        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)})'
+
+    def __getitem__[TProp](self, value: str | Column[TProp]) -> Optional[TProp]:
+        name = value if isinstance(value, str) else value.column_name
+        if hasattr(self, name):
+            return getattr(self, name)
+        return None
+
+    def to_dict(self) -> dict[str, str | int]:
+        dicc: dict[str, Any] = {}
+        for x in self.__annotations__:
+            dicc[x] = getattr(self, x)
+        return dicc
+
+    @classmethod
+    def get_pk(cls) -> Optional[Column]:
+        for obj in cls.__dict__.values():
+            if isinstance(obj, Column) and obj.is_primary_key:
+                return obj
+        return None
+
+    @classmethod
+    def get_columns(cls) -> tuple[Column, ...]:
+        return tuple([x for x in cls.__annotations__.values() if isinstance(x, Column)])
+
+    @classmethod
+    def get_column[TProp](cls, name: str) -> Column[TProp]:
+        for key, value in cls.__annotations__.items():
+            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 __eq__(self, __value: Any) -> bool:
+        if isinstance(__value, Table):
+            return all(
+                (
+                    self.__table_name__ == __value.__table_name__,
+                    tuple(self.to_dict().items()),
+                )
+            )
+        return False
+
+    @classmethod
+    def table_alias(cls, column: Optional[str] = None) -> str:
+        if column:
+            return f"`{cls.__table_name__}_{column}`"
+        return cls.__table_name__
+
+    @classmethod
+    def foreign_keys(cls) -> dict[str, ForeignKey]:
+        return {key: value for key, value in cls.__dict__.items() if isinstance(value, ForeignKey)}

ormlambda/sql/table/table_constructor.py

@@ -1,18 +1,6 @@
-from __future__ import annotations
-from decimal import Decimal
-from typing import Any, Optional, Type, dataclass_transform
-import base64
-import datetime
-import json
+from typing import Any, Type, dataclass_transform
 
-import shapely as sph
-
-
-from ormlambda.sql import Column
-from ormlambda.sql import ForeignKey
-from ormlambda.sql.dtypes import get_query_clausule
 from .fields import get_fields
-from ormlambda.utils.module_tree.dfs_traversal import DFSTraversal
 
 
 @dataclass_transform()
@@ -53,198 +41,3 @@ def __init_constructor__[T](cls: Type[T]) -> Type[T]:
 
     setattr(cls, "__init__", init_fn)
     return cls
-
-
-class TableMeta(type):
-    def __new__[T](cls: "Table", name: str, bases: tuple, dct: dict[str, Any]) -> Type[T]:
-        """
-        That's the class we use to recreate the table's metadata.
-        It's useful because we can dynamically create the __init__ method just by using the type hints of the variables we want to use as column names.
-        We simply call '__init_constructor__' to create all the necessary variables and the method.
-        """
-        cls_object: Table = super().__new__(cls, name, bases, dct)
-
-        if name == "Table":
-            return cls_object
-
-        if cls_object.__table_name__ is Ellipsis:
-            raise Exception(f"class variable '__table_name__' must be declared in '{cls_object.__name__}' class")
-
-        if not isinstance(cls_object.__table_name__, str):
-            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:
-        return f"{TableMeta.__name__}: {cls.__table_name__}"
-
-
-@dataclass_transform(eq_default=False)
-class Table(metaclass=TableMeta):
-    """
-    Class to mapped database tables with Python classes.
-
-    It uses __annotations__ special var to store all table columns. If you do not type class var it means this var is not store as table column
-    and it do not going to appear when you instantiate the object itself.
-
-    This principle it so powerful due to we can create Foreign Key references without break __init__ class method.
-
-    >>> class Address(Table):
-    >>>     __table_name__ = "address"
-
-    >>>     address_id: int = Column(int, is_primary_key=True)
-    >>>     address: str
-    >>>     address2: str
-    >>>     district: str
-    >>>     city_id: int
-    >>>     postal_code: datetime
-    >>>     phone: str
-    >>>     location: datetime
-    >>>     last_update: datetime = Column(datetime, is_auto_generated=True)
-
-    >>>     city = ForeignKey["Address", City](City, lambda a, c: a.city_id == c.city_id)
-    """
-
-    __table_name__: str = ...
-
-    def __str__(self) -> str:
-        params = self.to_dict()
-        return json.dumps(params, ensure_ascii=False, indent=2)
-
-    def __getattr__[T](self, _name: str) -> Column[T]:
-        return self.__dict__.get(_name, None)
-
-    def __repr__(self: "Table") -> str:
-        def __cast_long_variables(value: Any):
-            if not isinstance(value, str):
-                value = str(value)
-            if len(value) > 20:
-                return value[:20] + "..."
-            return value
-
-        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)})'
-
-    def __getitem__[TProp](self, value: str | Column[TProp]) -> Optional[TProp]:
-        name = value if isinstance(value, str) else value.column_name
-        if hasattr(self, name):
-            return getattr(self, name)
-        return None
-
-    def to_dict(self) -> dict[str, str | int]:
-        dicc: dict[str, Any] = {}
-        for x in self.__annotations__:
-            transform_data = self.__transform_data__(getattr(self, x))
-            dicc[x] = transform_data
-        return dicc
-
-    @staticmethod
-    def __transform_data__[T](_value: T) -> T:
-        def byte_to_string(value: bytes):
-            return base64.b64encode(value).decode("utf-8")
-
-        transform_map: dict = {
-            datetime.datetime: datetime.datetime.isoformat,
-            datetime.date: datetime.date.isoformat,
-            Decimal: str,
-            bytes: byte_to_string,
-            set: list,
-            sph.Point: lambda x: sph.to_wkt(x, rounding_precision=-1),
-        }
-
-        if (dtype := type(_value)) in transform_map:
-            return transform_map[dtype](_value)
-        return _value
-
-    @classmethod
-    def get_pk(cls) -> Optional[Column]:
-        for obj in cls.__dict__.values():
-            if isinstance(obj, Column) and obj.is_primary_key:
-                return obj
-        return None
-
-    @classmethod
-    def get_columns(cls) -> tuple[str, ...]:
-        return tuple([x for x in cls.__annotations__.values() if isinstance(x, Column)])
-
-    @classmethod
-    def get_column[TProp](cls, name: str) -> Column[TProp]:
-        for key, value in cls.__annotations__.items():
-            if name == key:
-                return value
-
-    @classmethod
-    def create_table_query(cls) -> str:
-        """It's classmethod because of it does not matter the columns values to create the table"""
-        all_clauses: list[str] = []
-
-        all_clauses.extend(cls._create_sql_column_query())
-        all_clauses.extend(ForeignKey.create_query(cls))
-
-        return f"CREATE TABLE {cls.__table_name__} ({', '.join(all_clauses)});"
-
-    @classmethod
-    def _create_sql_column_query(cls) -> list[str]:
-        """
-        It's imperative to instantiate cls() to initialize the 'Table' object and create private variables that will be Column objects.
-        Otherwise, we only can access to property method
-        """
-        annotations: dict[str, Column] = cls.__annotations__
-        all_columns: list = []
-        for col_obj in annotations.values():
-            all_columns.append(get_query_clausule(col_obj))
-        return all_columns
-
-    @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 __eq__(self, __value: Any) -> bool:
-        if isinstance(__value, Table):
-            return all(
-                (
-                    self.__table_name__ == __value.__table_name__,
-                    tuple(self.to_dict().items()),
-                )
-            )
-        return False
-
-    @classmethod
-    def table_alias(cls, column: Optional[str] = None) -> str:
-        if column:
-            return f"`{cls.__table_name__}_{column}`"
-        return cls.__table_name__
-
-    @classmethod
-    def foreign_keys(cls) -> dict[str, ForeignKey]:
-        return {key: value for key, value in cls.__dict__.items() if isinstance(value, ForeignKey)}

ormlambda/sql/type_api.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+from typing import Any, ClassVar
+from ormlambda.sql.visitors import Element
+import abc
+
+
+class TypeEngine[T: Any](Element, abc.ABC):
+    """
+    Base class for all SQL types.
+    """
+
+    __visit_name__ = "type_engine"
+
+    _sqla_type: ClassVar[bool] = True
+    _isnull: ClassVar[bool] = False
+    _is_tuple_type: ClassVar[bool] = False
+    _is_table_value: ClassVar[bool] = False
+    _is_array: ClassVar[bool] = False
+    _is_type_decorator: ClassVar[bool] = False
+    _type: ClassVar[T]
+
+    @property
+    @abc.abstractmethod
+    def python_type(self) -> T: ...
+
+    def _resolve_for_literal_value(self, value: T) -> TypeEngine[T]:
+        return self
+
+    def coerce_compared_value[TType](self, value: TType) -> TypeEngine[TType]:
+        from .sqltypes import resolve_primitive_types, NULLTYPE
+
+        _coerced_type = resolve_primitive_types(value)
+        if _coerced_type is NULLTYPE:
+            return self
+        return _coerced_type

ormlambda/sql/types.py

@@ -20,6 +20,8 @@ type UnionType = tp.Literal["AND", "OR", ""]
 type ComparerTypes = ComparerType | UnionType | ConditionEnum
 # endregion
 
-type TupleJoinType[T] = tuple[Comparer[T], JoinType]
+type TupleJoinType[T] = tuple[Comparer]
 
 ASTERISK: AsteriskType = "*"
+
+from .compiler import *

ormlambda/sql/visitors.py

@@ -0,0 +1,74 @@
+# Apply visitor pattern
+
+from __future__ import annotations
+import abc
+from typing import TYPE_CHECKING, ClassVar
+import operator
+
+if TYPE_CHECKING:
+    ...
+
+
+class Visitor(abc.ABC):
+    """
+    Abstract base class for all visitors in the SQL AST.
+    """
+
+    ensure_kwarg: ClassVar[str] = r"visit_\w+"
+
+    ...
+
+
+class Element:
+    """
+    Base class for all elements in the SQL AST.
+    """
+
+    __slots__ = ()
+
+    __visit_name__: ClassVar[str]
+    """
+    The name of the element used for dispatching in the visitor pattern.
+    This should be a string that uniquely identifies the type of element.
+    """
+
+    if TYPE_CHECKING:
+
+        def _compiler_dispatch(self, visitor: Visitor, **kw) -> str:
+            """
+            Dispatches the visitor to the appropriate method based on the type of the element.
+            """
+            ...
+
+    @classmethod
+    def __init_subclass__(cls):
+        if "__visit_name__" in cls.__dict__:
+            cls._generate_compiler_dispatch()
+        return super().__init_subclass__()
+
+    @classmethod
+    def _generate_compiler_dispatch(cls):
+        """
+        Generates the _compiler_dispatch method for the class.
+        """
+        visit_name = cls.__visit_name__
+
+        if not isinstance(visit_name, str):
+            raise TypeError(f"__visit_name__ must be a string, not {type(visit_name).__name__}")
+
+        name = f"visit_{visit_name}"
+        getter = operator.attrgetter(name)
+
+        def _compiler_dispatch(self, visitor: Visitor, **kw) -> str:
+            """
+            Dispatches the visitor to the appropriate method based on the type of the element.
+            """
+            try:
+                meth = getter(visitor)
+                return meth(self, **kw)
+
+            except AttributeError as err:
+                raise err
+                # return visitor.visit_unsupported_compilation(self, err, **kw)  # type: ignore  # noqa: E501
+
+        cls._compiler_dispatch = _compiler_dispatch

ormlambda/statements/__init__.py

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

ormlambda/statements/base_statement.py

@@ -7,32 +7,38 @@ from ormlambda.repository import BaseRepository
 from ormlambda.statements.interfaces import IStatements_two_generic
 from ormlambda import Table
 
-from ormlambda.sql.clause_info import AggregateFunctionBase
-from ormlambda.caster.caster import Caster
-
+from ormlambda.common.errors import AggregateFunctionError
 
 if TYPE_CHECKING:
-    from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
-    from ormlambda.sql.clause_info import ClauseInfo
+    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], repository: BaseRepository) -> None:
-        self.__valid_repository(repository)
-
+    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,)
-        self._repository: BaseRepository = repository
+
+        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__)
@@ -47,13 +53,12 @@ class BaseStatement[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
         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, model=self._model, select=select, **kwargs)
+        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, model=self._model, select=select)  # store all columns of the SQL query
-
+        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 ClusterQuery(self.repository, select, response_sql).clean_response()
+            return ClusterResponse(self._dialect, select, response_sql).cluster()
 
         return response_sql
 
@@ -75,15 +80,15 @@ class BaseStatement[T: Table, TRepo](IStatements_two_generic[T, TRepo]):
         return self._repository
 
 
-class ClusterQuery[T]:
-    def __init__(self, repository: BaseRepository, select: DecompositionQueryBase[T], response_sql: tuple[dict[str, Any]]) -> None:
-        self._repository: BaseRepository = repository
-        self._select: DecompositionQueryBase[T] = select
+class ClusterResponse[T]:
+    def __init__(self, dialect: Dialect, select: Select[T], response_sql: tuple[dict[str, Any]]) -> None:
+        self._dialect: Dialect = dialect
+        self._select: Select[T] = select
         self._response_sql: tuple[dict[str, Any]] = response_sql
-        self._caster = Caster(repository)
+        self._caster = dialect.caster
 
-    def clean_response(self) -> tuple[dict[Type[Table], tuple[Table, ...]]]:
-        tbl_dicc: dict[Type[Table], list[dict[str, Any]]] = self.__loop_foo()
+    def cluster(self) -> tuple[dict[Type[Table], tuple[Table, ...]]]:
+        tbl_dicc: dict[Type[Table], list[dict[str, Any]]] = self._create_cluster()
 
         response = {}
         tuple_response = []
@@ -91,13 +96,12 @@ class ClusterQuery[T]:
         for table, attribute_list in tbl_dicc.items():
             new_instance = []
             for attrs in attribute_list:
-                casted_attr = {key: self._caster.for_value(value, table.get_column(key).dtype).from_database for key, value in attrs.items()}
-                new_instance.append(table(**casted_attr))
+                new_instance.append(table(**attrs))
             response[table] = tuple(new_instance)
             tuple_response.append(tuple(new_instance))
         return tuple(tuple_response)
 
-    def __loop_foo(self) -> dict[Type[Table], list[dict[str, Any]]]:
+    def _create_cluster(self) -> 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)
 
@@ -112,22 +116,8 @@ class ClusterQuery[T]:
                 col = clause.column
 
                 if col is None or not hasattr(table, col):
-                    agg_methods = self.__get_all_aggregate_method(clause)
-                    raise ValueError(f"You cannot use aggregation method like '{agg_methods}' to return model objects. Try specifying 'flavour' attribute as 'dict'.")
+                    raise AggregateFunctionError(clause)
 
                 table_attr_dict[table][i][col] = dicc_cols[clause.alias_clause]
-
         # Convert back to a normal dict if you like (defaultdict is a dict subclass).
         return dict(table_attr_dict)
-
-    def __get_all_aggregate_method(self, clauses: list[ClauseInfo]) -> str:
-        """
-        Get the class name of those classes that inherit from 'AggregateFunctionBase' class in order to create a better error message.
-        """
-        res: set[str] = set()
-        if not isinstance(clauses, Iterable):
-            return clauses.__class__.__name__
-        for clause in clauses:
-            if isinstance(clause, AggregateFunctionBase):
-                res.add(clause.__class__.__name__)
-        return ", ".join(res)