ormlambda 3.11.2__py3-none-any.whl → 3.34.0__py3-none-any.whl

ormlambda/repository/response.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+from typing import Type, Any, TYPE_CHECKING, Optional
+from ormlambda.dialects.interface.dialect import Dialect
+import shapely as shp
+
+# Custom libraries
+from ormlambda.sql.clauses import Alias
+
+if TYPE_CHECKING:
+    from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
+    from ormlambda import Table
+    from ormlambda.sql.clauses import Select
+
+
+type TResponse[TFlavour, *Ts] = TFlavour | tuple[dict[str, tuple[*Ts]]] | tuple[tuple[*Ts]] | tuple[TFlavour]
+
+
+class Response[TFlavour, *Ts]:
+    def __init__(
+        self,
+        dialect: Dialect,
+        response_values: list[tuple[*Ts]],
+        columns: tuple[str],
+        flavour: Type[TFlavour],
+        select: Optional[Select] = None,
+    ) -> None:
+        self._dialect: Dialect = dialect
+        self._response_values: list[tuple[*Ts]] = response_values
+        self._columns: tuple[str] = columns
+        self._flavour: Type[TFlavour] = flavour
+        self._select: Select = select
+
+        self._response_values_index: int = len(self._response_values)
+
+        self._caster = dialect.caster()
+
+    @property
+    def is_one(self) -> bool:
+        return self._response_values_index == 1
+
+    @property
+    def is_there_response(self) -> bool:
+        return self._response_values_index != 0
+
+    @property
+    def is_many(self) -> bool:
+        return self._response_values_index > 1
+
+    def response(self, **kwargs) -> TResponse[TFlavour, *Ts]:
+        if not self.is_there_response:
+            return tuple([])
+
+        # Cast data using caster
+        cleaned_response = self._response_values
+
+        if self._select is not None:
+            cleaned_response = self._clean_response()
+
+        cast_flavour = self._cast_to_flavour(cleaned_response, **kwargs)
+
+        return tuple(cast_flavour)
+
+    def _cast_to_flavour(self, data: list[tuple[*Ts]], **kwargs) -> list[dict[str, tuple[*Ts]]] | list[tuple[*Ts]] | list[TFlavour]:
+        def _dict(**kwargs) -> list[dict[str, tuple[*Ts]]]:
+            nonlocal data
+            return [dict(zip(self._columns, x)) for x in data]
+
+        def _tuple(**kwargs) -> list[tuple[*Ts]]:
+            nonlocal data
+            return data
+
+        def _set(**kwargs) -> list[set]:
+            nonlocal data
+            for d in data:
+                n = len(d)
+                for i in range(n):
+                    try:
+                        hash(d[i])
+                    except TypeError:
+                        raise TypeError(f"unhashable type '{type(d[i])}' found in '{type(d)}' when attempting to cast the result into a '{set.__name__}' object")
+            return [set(x) for x in data]
+
+        def _list(**kwargs) -> list[list]:
+            nonlocal data
+            return [list(x) for x in data]
+
+        def _default(**kwargs) -> list[TFlavour]:
+            nonlocal data
+            replacer_dicc: dict[str, str] = {}
+
+            for col in self._select.all_clauses:
+                if hasattr(col, "_alias_aggregate") or col.alias_clause is None or isinstance(col, Alias):
+                    continue
+                replacer_dicc[col.alias_clause] = col.column
+
+            cleaned_column_names = [replacer_dicc.get(col, col) for col in self._columns]
+
+            result = []
+            for attr in data:
+                dicc_attr = dict(zip(cleaned_column_names, attr))
+                result.append(self._flavour(**dicc_attr, **kwargs))
+
+            return result
+
+        selector: dict[Type[object], Any] = {
+            dict: _dict,
+            tuple: _tuple,
+            set: _set,
+            list: _list,
+        }
+        return selector.get(self._flavour, _default)(**kwargs)
+
+    def _clean_response(self) -> TFlavour:
+        new_response: list[tuple] = []
+        for row in self._response_values:
+            new_row: list = []
+            for i, data in enumerate(row):
+                alias = self._columns[i]
+                clause_info = self._select[alias]
+                parse_data = self._caster.for_value(data, value_type=clause_info.dtype).from_database
+                new_row.append(parse_data)
+            new_row = tuple(new_row)
+            if not isinstance(new_row, tuple):
+                new_row = tuple(new_row)
+
+            new_response.append(new_row)
+        return new_response
+
+    @staticmethod
+    def _is_parser_required[T: Table](clause_info: ClauseInfo[T]) -> bool:
+        if clause_info is None:
+            return False
+
+        return clause_info.dtype is shp.Point

ormlambda/sql/clause_info/__init__.py

@@ -1,3 +1,4 @@
 from .interface import IAggregate  # noqa: F401
-from .clause_info import ClauseInfo, AggregateFunctionBase  # noqa: F401
+from .clause_info import ClauseInfo  # noqa: F401
+from .aggregate_function_base import AggregateFunctionBase  # noqa: F401
 from .clause_info_context import ClauseContextType, ClauseInfoContext  # noqa: F401

ormlambda/sql/clause_info/aggregate_function_base.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+import abc
+import typing as tp
+
+from ormlambda import Table
+from ormlambda import Column
+from ormlambda.sql.types import (
+    TableType,
+    ColumnType,
+    AliasType,
+)
+from .interface import IAggregate
+from ormlambda.common.errors import NotKeysInIAggregateError
+from ormlambda.sql import ForeignKey
+from ormlambda.sql.table import TableMeta
+from .clause_info import ClauseInfo
+from .clause_info_context import ClauseContextType
+
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
+
+class AggregateFunctionBase[T: Table](ClauseInfo[T], IAggregate):
+    def __init__[TProp: Column](
+        self,
+        table: TableType[T],
+        column: tp.Optional[ColumnType[TProp]] = None,
+        alias_table: tp.Optional[AliasType[ClauseInfo[T]]] = None,
+        alias_clause: tp.Optional[AliasType[ClauseInfo[T]]] = None,
+        context: ClauseContextType = None,
+        keep_asterisk: bool = False,
+        preserve_context: bool = False,
+        dtype: TProp = None,
+        *,
+        dialect: Dialect,
+        **kw,
+    ):
+        self._alias_aggregate = alias_clause
+        super().__init__(
+            table=table,
+            column=column,
+            alias_table=alias_table,
+            context=context,
+            keep_asterisk=keep_asterisk,
+            preserve_context=preserve_context,
+            dtype=dtype,
+            dialect=dialect,
+            **kw,
+        )
+
+    @staticmethod
+    @abc.abstractmethod
+    def FUNCTION_NAME() -> str: ...
+
+    @classmethod
+    def _convert_into_clauseInfo[TypeColumns, TProp](cls, columns: ClauseInfo | ColumnType[TProp], context: ClauseContextType, dialect: Dialect) -> list[ClauseInfo]:
+        type DEFAULT = tp.Literal["default"]
+        type ClusterType = ColumnType | ForeignKey | DEFAULT
+
+        dicc_type: dict[ClusterType, tp.Callable[[ClusterType], ClauseInfo]] = {
+            Column: lambda column: ClauseInfo(column.table, column, context=context, dialect=dialect),
+            ClauseInfo: lambda column: column,
+            ForeignKey: lambda tbl: ClauseInfo(tbl.tright, tbl.tright, context=context, dialect=dialect),
+            TableMeta: lambda tbl: ClauseInfo(tbl, tbl, context=context, dialect=dialect),
+            "default": lambda column: ClauseInfo(table=None, column=column, context=context, dialect=dialect),
+        }
+        all_clauses: list[ClauseInfo] = []
+        if isinstance(columns, str) or not isinstance(columns, tp.Iterable):
+            columns = (columns,)
+        for value in columns:
+            all_clauses.append(dicc_type.get(type(value), dicc_type["default"])(value))
+
+        return all_clauses
+
+    @tp.override
+    def query(self, dialect: Dialect, **kwargs) -> str:
+        wrapped_ci = self.wrapped_clause_info(self)
+        if not self._alias_aggregate:
+            return wrapped_ci
+
+        return ClauseInfo(
+            table=None,
+            column=wrapped_ci,
+            alias_clause=self._alias_aggregate,
+            context=self._context,
+            keep_asterisk=self._keep_asterisk,
+            preserve_context=self._preserve_context,
+            dialect=self._dialect,
+        ).query(dialect, **kwargs)
+
+    def wrapped_clause_info(self, ci: ClauseInfo[T]) -> str:
+        # avoid use placeholder when using IAggregate because no make sense.
+        if self._alias_aggregate and (found := self._keyRegex.findall(self._alias_aggregate)):
+            raise NotKeysInIAggregateError(found)
+
+        return f"{self.FUNCTION_NAME()}({ci._create_query(self._dialect)})"

ormlambda/sql/clause_info/clause_info.py

@@ -1,26 +1,24 @@
 from __future__ import annotations
-import abc
 import typing as tp
 import re
 
 from ormlambda import Table
 from ormlambda import Column
-from ormlambda.common.interfaces.IQueryCommand import IQuery
 from ormlambda.sql.types import (
     ASTERISK,
     TableType,
     ColumnType,
     AliasType,
 )
-from .interface import IAggregate
-from ormlambda.common.errors import NotKeysInIAggregateError
+from .interface import IClauseInfo
 from ormlambda.sql import ForeignKey
-from ormlambda.sql.table import TableMeta
-from ormlambda.caster import Caster
 
 
 from .clause_info_context import ClauseInfoContext, ClauseContextType
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
 
 class ReplacePlaceholderError(ValueError):
     def __init__(self, placeholder: str, attribute: str, *args):
@@ -32,30 +30,6 @@ class ReplacePlaceholderError(ValueError):
         return "You cannot use {" + self.placeholder + "} placeholder without using '" + self.attr + "' attribute"
 
 
-class IClauseInfo[T: Table](IQuery):
-    @property
-    @abc.abstractmethod
-    def table(self) -> TableType[T]: ...
-    @property
-    @abc.abstractmethod
-    def alias_clause(self) -> tp.Optional[str]: ...
-    @property
-    @abc.abstractmethod
-    def alias_table(self) -> tp.Optional[str]: ...
-    @property
-    @abc.abstractmethod
-    def column(self) -> str: ...
-    @property
-    @abc.abstractmethod
-    def unresolved_column(self) -> ColumnType: ...
-    @property
-    @abc.abstractmethod
-    def context(self) -> ClauseContextType: ...
-    @property
-    @abc.abstractmethod
-    def dtype[TProp](self) -> tp.Optional[tp.Type[TProp]]: ...
-
-
 class ClauseInfo[T: Table](IClauseInfo[T]):
     _keyRegex: re.Pattern = re.compile(r"{([^{}:]+)}")
 
@@ -73,6 +47,11 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
     def __init__(self, table: TableType[T], keep_asterisk: tp.Optional[bool] = ...): ...
     @tp.overload
     def __init__(self, table: TableType[T], preserve_context: tp.Optional[bool] = ...): ...
+    @tp.overload
+    def __init__[TProp](self, table: TableType[T], dtype: tp.Optional[TProp] = ...): ...
+
+    @tp.overload
+    def __init__(self, dialect: Dialect, *args, **kwargs): ...
 
     def __init__[TProp](
         self,
@@ -83,6 +62,10 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         context: ClauseContextType = None,
         keep_asterisk: bool = False,
         preserve_context: bool = False,
+        dtype: tp.Optional[TProp] = None,
+        *,
+        dialect: Dialect,
+        **kw,
     ):
         if not self.is_table(table):
             column = table if not column else column
@@ -95,6 +78,9 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         self._context: ClauseContextType = context if context else ClauseInfoContext()
         self._keep_asterisk: bool = keep_asterisk
         self._preserve_context: bool = preserve_context
+        self._dtype = dtype
+
+        self._dialect: Dialect = dialect
 
         self._placeholderValues: dict[str, tp.Callable[[TProp], str]] = {
             "column": self.replace_column_placeholder,
@@ -104,8 +90,10 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         if not self._preserve_context and (self._context and any([alias_table, alias_clause])):
             self._context.add_clause_to_context(self)
 
+        super().__init__(**kw)
+
     def __repr__(self) -> str:
-        return f"{type(self).__name__}: query -> {self.query}"
+        return f"{type(self).__name__}: query -> {self.query(self._dialect)}"
 
     def replace_column_placeholder[TProp](self, column: ColumnType[TProp]) -> str:
         if not column:
@@ -168,6 +156,9 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
 
     @property
     def dtype[TProp](self) -> tp.Optional[tp.Type[TProp]]:
+        if self._dtype is not None:
+            return self._dtype
+
         if isinstance(self._column, Column):
             return self._column.dtype
 
@@ -175,11 +166,10 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
             return self._column
         return type(self._column)
 
-    @property
-    def query(self) -> str:
-        return self._create_query()
+    def query(self, dialect: Dialect, **kwargs) -> str:
+        return self._create_query(dialect, **kwargs)
 
-    def _create_query(self) -> str:
+    def _create_query(self, dialect: Dialect, **kwargs) -> str:
         # when passing some value that is not a column name
         if not self.table and not self._alias_clause:
             return self.column
@@ -201,10 +191,9 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         return self._join_table_and_column(self._column)
 
     def _join_table_and_column[TProp](self, column: ColumnType[TProp]) -> str:
-        # FIXME [ ]: Study how to deacoplate from mysql database
-        from ormlambda.databases.my_sql.repository import MySQLRepository
+        # FIXME [x]: Study how to deacoplate from mysql database
 
-        caster = Caster(MySQLRepository)
+        caster = self._dialect.caster()
 
         if self.alias_table:
             table = self._wrapped_with_quotes(self.alias_table)
@@ -241,22 +230,20 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
                 alias_clause=self._alias_clause,
                 context=self._context,
                 keep_asterisk=self._keep_asterisk,
+                dialect=self._dialect,
             )
 
         if self._alias_table and self._alias_clause:  # We'll add an "*" when we are certain that we have included 'alias_clause' attr
             return self._join_table_and_column(ASTERISK)
 
-        columns: list[ClauseInfo] = [ClauseCreator(column).query for column in self.table.get_columns()]
+        columns: list[ClauseInfo] = [ClauseCreator(column).query(self._dialect) for column in self.table.get_columns()]
 
         return ", ".join(columns)
 
-    # FIXME [ ]: Study how to deacoplate from mysql database
+    # FIXME [x]: Study how to deacoplate from mysql database
     def _column_resolver[TProp](self, column: ColumnType[TProp]) -> str:
-        from ormlambda.databases.my_sql.repository import MySQLRepository
-
-        caster = Caster(MySQLRepository)
         if isinstance(column, ClauseInfo):
-            return column.query
+            return column.query(self._dialect)
 
         if isinstance(column, tp.Iterable) and isinstance(column[0], ClauseInfo):
             return self.join_clauses(column)
@@ -277,6 +264,7 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         if self.is_foreign_key(self._column):
             return self._column.tright.__table_name__
 
+        caster = self._dialect.caster()
         casted_value = caster.for_value(column, self.dtype)
         if not self._table:
             # if we haven't some table atrribute, we assume that the user want to retrieve the string_data from caster.
@@ -320,12 +308,13 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         return self._context.get_table_alias(self.table)
 
     @staticmethod
-    def join_clauses(clauses: list[ClauseInfo[T]], chr: str = ",", context: tp.Optional[ClauseInfoContext] = None) -> str:
+    def join_clauses(clauses: list[ClauseInfo[T]], chr: str = ",", context: tp.Optional[ClauseInfoContext] = None, *, dialect: Dialect) -> str:
         queries: list[str] = []
         for c in clauses:
             if context:
                 c.context = context
-            queries.append(c.query)
+                c._dialect = dialect
+            queries.append(c.query(dialect))
 
         return f"{chr} ".join(queries)
 
@@ -363,72 +352,3 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         if isinstance(data, Column):
             return True
         return False
-
-
-class AggregateFunctionBase[T: Table](ClauseInfo[T], IAggregate):
-    def __init__[TProp: Column](
-        self,
-        table: TableType[T],
-        column: tp.Optional[ColumnType[TProp]] = None,
-        alias_table: tp.Optional[AliasType[ClauseInfo[T]]] = None,
-        alias_clause: tp.Optional[AliasType[ClauseInfo[T]]] = None,
-        context: ClauseContextType = None,
-        keep_asterisk: bool = False,
-        preserve_context: bool = False,
-    ):
-        self._alias_aggregate = alias_clause
-        super().__init__(
-            table=table,
-            column=column,
-            alias_table=alias_table,
-            context=context,
-            keep_asterisk=keep_asterisk,
-            preserve_context=preserve_context,
-        )
-
-    @staticmethod
-    @abc.abstractmethod
-    def FUNCTION_NAME() -> str: ...
-
-    @classmethod
-    def _convert_into_clauseInfo[TypeColumns, TProp](cls, columns: ClauseInfo | ColumnType[TProp], context: ClauseContextType) -> list[ClauseInfo]:
-        type DEFAULT = tp.Literal["default"]
-        type ClusterType = ColumnType | ForeignKey | DEFAULT
-
-        dicc_type: dict[ClusterType, tp.Callable[[ClusterType], ClauseInfo]] = {
-            Column: lambda column: ClauseInfo(column.table, column, context=context),
-            ClauseInfo: lambda column: column,
-            ForeignKey: lambda tbl: ClauseInfo(tbl.tright, tbl.tright, context=context),
-            TableMeta: lambda tbl: ClauseInfo(tbl, tbl, context=context),
-            "default": lambda column: ClauseInfo(table=None, column=column, context=context),
-        }
-        all_clauses: list[ClauseInfo] = []
-        if isinstance(columns, str) or not isinstance(columns, tp.Iterable):
-            columns = (columns,)
-        for value in columns:
-            all_clauses.append(dicc_type.get(type(value), dicc_type["default"])(value))
-
-        return all_clauses
-
-    @tp.override
-    @property
-    def query(self) -> str:
-        wrapped_ci = self.wrapped_clause_info(self)
-        if not self._alias_aggregate:
-            return wrapped_ci
-
-        return ClauseInfo(
-            table=None,
-            column=wrapped_ci,
-            alias_clause=self._alias_aggregate,
-            context=self._context,
-            keep_asterisk=self._keep_asterisk,
-            preserve_context=self._preserve_context,
-        ).query
-
-    def wrapped_clause_info(self, ci: ClauseInfo[T]) -> str:
-        # avoid use placeholder when using IAggregate because no make sense.
-        if self._alias_aggregate and (found := self._keyRegex.findall(self._alias_aggregate)):
-            raise NotKeysInIAggregateError(found)
-
-        return f"{self.FUNCTION_NAME()}({ci._create_query()})"

ormlambda/sql/clause_info/interface/IClauseInfo.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+import abc
+import typing as tp
+
+from ormlambda import Table
+from ormlambda.common.interfaces.IQueryCommand import IQuery
+from ormlambda.sql.types import (
+    TableType,
+    ColumnType,
+)
+
+
+from ..clause_info_context import ClauseContextType
+
+
+class IClauseInfo[T: Table](IQuery):
+    @property
+    @abc.abstractmethod
+    def table(self) -> TableType[T]: ...
+    @property
+    @abc.abstractmethod
+    def alias_clause(self) -> tp.Optional[str]: ...
+    @property
+    @abc.abstractmethod
+    def alias_table(self) -> tp.Optional[str]: ...
+    @property
+    @abc.abstractmethod
+    def column(self) -> str: ...
+    @property
+    @abc.abstractmethod
+    def unresolved_column(self) -> ColumnType: ...
+    @property
+    @abc.abstractmethod
+    def context(self) -> ClauseContextType: ...
+    @property
+    @abc.abstractmethod
+    def dtype[TProp](self) -> tp.Optional[tp.Type[TProp]]: ...

ormlambda/sql/clause_info/interface/__init__.py

@@ -1 +1,2 @@
 from .IAggregate import IAggregate  # noqa: F401
+from .IClauseInfo import IClauseInfo  # noqa: F401

ormlambda/sql/clauses/__init__.py

@@ -0,0 +1,14 @@
+from .alias import Alias  # noqa: F401
+from .count import Count  # noqa: F401
+from .delete import Delete  # noqa: F401
+from .group_by import GroupBy  # noqa: F401
+from .insert import Insert  # noqa: F401
+from .joins import JoinSelector  # noqa: F401
+from .limit import Limit  # noqa: F401
+from .offset import Offset  # noqa: F401
+from .order import Order  # noqa: F401
+from .select import Select  # noqa: F401
+from .where import Where  # noqa: F401
+from .having import Having  # noqa: F401
+from .update import Update  # noqa: F401
+from .upsert import Upsert  # noqa: F401

ormlambda/{databases/my_sql → sql}/clauses/alias.py

@@ -1,18 +1,21 @@
 from __future__ import annotations
 import typing as tp
 
-from ormlambda import Table
 from ormlambda.sql.clause_info import ClauseInfo
-from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
-from ormlambda.sql.types import TableType
+from ormlambda.sql.elements import ClauseElement
+
 
 if tp.TYPE_CHECKING:
-    from ormlambda.sql.types import ColumnType
     from ormlambda import Table
+    from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+    from ormlambda.sql.types import TableType
+    from ormlambda.sql.types import ColumnType
     from ormlambda.sql.types import AliasType
 
 
-class Alias[T: Table](ClauseInfo[T]):
+class Alias[T: Table](ClauseInfo[T], ClauseElement):
+    __visit_name__ = "alias"
+
     def __init__[TProp](
         self,
         table: TableType[T],
@@ -22,7 +25,21 @@ class Alias[T: Table](ClauseInfo[T]):
         context: ClauseContextType = None,
         keep_asterisk: bool = False,
         preserve_context: bool = False,
+        **kw,
     ):
         if not alias_clause:
             raise TypeError
-        super().__init__(table, column, alias_table, alias_clause, context, keep_asterisk, preserve_context)
+        super().__init__(
+            table,
+            column,
+            alias_table=alias_table,
+            alias_clause=alias_clause,
+            context=context,
+            keep_asterisk=keep_asterisk,
+            preserve_context=preserve_context,
+            dtype=None,
+            **kw,
+        )
+
+
+__all__ = ["Alias"]

ormlambda/{databases/my_sql → sql}/clauses/count.py

@@ -9,13 +9,18 @@ from ormlambda import Table
 import typing as tp
 
 from ormlambda.sql.types import ASTERISK
+from ormlambda.sql.elements import ClauseElement
+
 
 if tp.TYPE_CHECKING:
     from ormlambda import Table
     from ormlambda.sql.types import ColumnType, AliasType, TableType
+    from ormlambda.dialects import Dialect
+
 
+class Count[T: Table](AggregateFunctionBase[T], ClauseElement):
+    __visit_name__ = "count"
 
-class Count[T: Table](AggregateFunctionBase[T]):
     @staticmethod
     def FUNCTION_NAME() -> str:
         return "COUNT"
@@ -28,6 +33,9 @@ class Count[T: Table](AggregateFunctionBase[T]):
         context: ClauseContextType = None,
         keep_asterisk: bool = True,
         preserve_context: bool = True,
+        *,
+        dialect: Dialect,
+        **kw,
     ) -> None:
         table = self.extract_table(element)
         column = element if self.is_column(element) else ASTERISK
@@ -40,4 +48,10 @@ class Count[T: Table](AggregateFunctionBase[T]):
             context=context,
             keep_asterisk=keep_asterisk,
             preserve_context=preserve_context,
+            dtype=int,
+            dialect=dialect,
+            **kw,
         )
+
+
+__all__ = ["Count"]