ormlambda 4.0.5__tar.gz → 4.4.0__tar.gz

{ormlambda-4.0.5 → ormlambda-4.4.0}/PKG-INFO

@@ -1,13 +1,12 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: ormlambda
-Version: 4.0.5
+Version: 4.4.0
 Summary: ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions
 Author: p-hzamora
 Author-email: p.hzamora@icloud.com
 Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: mysql-connector-python (>=9.0.0,<10.0.0)
 Requires-Dist: shapely (>=2.0.6,<3.0.0)
 Description-Content-Type: text/markdown

{ormlambda-4.0.5 → ormlambda-4.4.0}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "4.0.5"
+version = "4.4.0"
 description = "ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions"
 authors = ["p-hzamora <p.hzamora@icloud.com>"]
 readme = "README.md"

{ormlambda-4.0.5 → ormlambda-4.4.0}/src/ormlambda/__init__.py

@@ -62,7 +62,6 @@ from .sql.sqltypes import POINT as POINT
 
 
 from .sql.clauses import Alias as Alias
-from .sql.clauses import Count as Count
 from .sql.clauses import Delete as Delete
 from .sql.clauses import GroupBy as GroupBy
 from .sql.clauses import Insert as Insert
@@ -76,12 +75,9 @@ from .sql.clauses import Having as Having
 from .sql.clauses import Update as Update
 from .sql.clauses import Upsert as Upsert
 
-from .sql.functions import Max as Max
-from .sql.functions import Min as Min
-from .sql.functions import Concat as Concat
-from .sql.functions import Sum as Sum
-
+from .sql import functions as functions
 
+from .sql.functions import *  # noqa: F403
 from . import util as _util
 
 _util.import_prefix("ormlambda")

{ormlambda-4.0.5 → ormlambda-4.4.0}/src/ormlambda/common/enums/__init__.py

@@ -1,3 +1,4 @@
 from .join_type import JoinType  # noqa: F401
 from .condition_types import ConditionType  # noqa: F401
-from .order_type  import OrderType  # noqa: F401
+from .order_type import OrderType  # noqa: F401
+from .union_type import UnionEnum  # noqa: F401

{ormlambda-4.0.5 → ormlambda-4.4.0}/src/ormlambda/common/enums/condition_types.py

@@ -1,7 +1,7 @@
 from enum import Enum
 
 
-class ConditionType(Enum):
+class ConditionType(str, Enum):
     EQUAL = "="
     LESS_THAN = "<"
     GREATER_THAN = ">"
@@ -15,3 +15,6 @@ class ConditionType(Enum):
     NOT_IN = "NOT IN"
     IS = "IS"
     IS_NOT = "IS NOT"
+
+    def __str__(self):
+        return super().__str__()

ormlambda-4.4.0/src/ormlambda/common/enums/union_type.py

@@ -0,0 +1,9 @@
+import enum
+
+
+class UnionEnum(str, enum.Enum):
+    AND = "AND"
+    OR = "OR"
+
+    def __str__(self):
+        return super().__str__()

{ormlambda-4.0.5 → ormlambda-4.4.0}/src/ormlambda/common/errors/__init__.py

@@ -18,16 +18,16 @@ class UnmatchedLambdaParameterError(Exception):
         return f"Unmatched number of parameters in lambda function with the number of tables: Expected {self.expected_params} parameters but found {str(self.found_param)}."
 
 
-class NotKeysInIAggregateError(Exception):
+class NotKeysInIFunctionError(Exception):
     def __init__(self, match_regex: list[str], *args: object) -> None:
         super().__init__(*args)
         self._match_regex: list[str] = match_regex
 
     def __str__(self) -> str:
-        return f"We cannot use placeholders in IAggregate class. You used {self._match_regex}"
+        return f"We cannot use placeholders in IFunction class. You used {self._match_regex}"
 
 
-class AggregateFunctionError[T](Exception):
+class FunctionFunctionError[T](Exception):
     def __init__(self, clause: ClauseInfo[T], *args):
         self.clause = clause
         super().__init__(*args)
@@ -36,18 +36,18 @@ class AggregateFunctionError[T](Exception):
         agg_methods = self.__get_all_aggregate_method(self.clause)
         return f"You cannot use aggregation method like '{agg_methods}' to return model objects. Try specifying 'flavour' attribute as 'dict'."
 
-    @util.preload_module("ormlambda.sql.clause_info")
+    @util.preload_module("ormlambda.sql.functions")
     def __get_all_aggregate_method(self, clauses: list[ClauseInfo]) -> str:
         """
-        Get the class name of those classes that inherit from 'IAggregate' class in order to create a better error message.
+        Get the class name of those classes that inherit from 'IFunction' class in order to create a better error message.
         """
 
-        IAggregate = util.preloaded.sql_clause_info.IAggregate
+        IFunction = util.preloaded.sql_functions.IFunction 
         res: set[str] = set()
         if not isinstance(clauses, tp.Iterable):
             return clauses.__class__.__name__
         for clause in clauses:
-            if isinstance(clause, IAggregate):
+            if isinstance(clause, IFunction):
                 res.add(clause.__class__.__name__)
         return ", ".join(res)
 
@@ -56,5 +56,5 @@ class NotCallableError(ValueError):
     def __init__(self, *args):
         super().__init__(*args)
 
-    def __str__(self)->str:
-        return f"You must provide a function or callable to proceed with the query creation. Passed '{self.args[0].__class__.__name__}' "
+    def __str__(self) -> str:
+        return f"You must provide a function or callable to proceed with the query creation. Passed '{self.args[0].__class__.__name__}' "

{ormlambda-4.0.5 → ormlambda-4.4.0}/src/ormlambda/common/interfaces/__init__.py

@@ -1,3 +1,2 @@
 from .IJoinSelector import IJoinSelector as IJoinSelector
-from .INonQueryCommand import INonQueryCommand as INonQueryCommand
 from .IQueryCommand import IQuery as IQuery

{ormlambda-4.0.5 → ormlambda-4.4.0}/src/ormlambda/dialects/mysql/base.py

@@ -1,19 +1,21 @@
 from __future__ import annotations
 from types import ModuleType
-from ormlambda import ColumnProxy, ForeignKey, TableProxy
+from ormlambda import ColumnProxy, ForeignKey, TableProxy, Table, Column
 from ormlambda.sql import compiler
 from ormlambda.sql.clause_info import ClauseInfo
-from ormlambda.common.errors import NotKeysInIAggregateError
+from ormlambda.common.errors import NotKeysInIFunctionError
 from ormlambda.sql.types import ASTERISK
 
 
 from .. import default
-from typing import TYPE_CHECKING, Any, Iterable
+from typing import TYPE_CHECKING, Any, Iterable, Type
+from ormlambda.sql.comparer import Comparer, ComparerCluster
 
 if TYPE_CHECKING:
+    from ormlambda.sql.functions.interface import IFunction
+    from ormlambda.sql.types import ColumnType
     from test.test_clause_info import ST_Contains
     from ormlambda import JoinSelector
-    from ormlambda.sql.comparer import Comparer
     from ormlambda.sql.column.column import Column
     from mysql import connector
     from ormlambda.dialects.mysql.clauses import ST_AsText
@@ -70,7 +72,6 @@ if TYPE_CHECKING:
         Update,
         Limit,
         Offset,
-        Count,
         Where,
         Having,
         Order,
@@ -78,10 +79,21 @@ if TYPE_CHECKING:
     )
 
     from ormlambda.sql.functions import (
-        Concat,
         Max,
         Min,
+        Concat,
         Sum,
+        Count,
+        Avg,
+        Abs,
+        Ceil,
+        Floor,
+        Round,
+        Pow,
+        Sqrt,
+        Mod,
+        Rand,
+        Truncate,
     )
 
 
@@ -129,6 +141,12 @@ class MySQLCompiler(compiler.SQLCompiler):
             column.alias = clause_info.alias_clause
         return clause_info.query(self.dialect)
 
+    def visit_comparer_cluster(self, cluster: ComparerCluster, **kw) -> str:
+        c1 = cluster.left_comparer.compile(self.dialect, **kw).string
+        c2 = cluster.right_comparer.compile(self.dialect, **kw).string
+
+        return f"{c1} {cluster.join} {c2}"
+
     def visit_comparer(self, comparer: Comparer, **kwargs) -> str:
         from ormlambda.sql.comparer import CleanValue, Comparer
 
@@ -149,6 +167,48 @@ class MySQLCompiler(compiler.SQLCompiler):
 
         return f"{lcond} {comparer.compare} {rcond}"
 
+    def visit_where(self, where: Where) -> str:
+        assert (n := len(where.comparers)) == len(where.restrictive)
+
+        if not where.comparers:
+            return ""
+
+        cond = []
+
+        for i in range(n):
+            comp = where.comparers[i]
+
+            string = comp.compile(self.dialect).string
+
+            condition = f"({string})" if isinstance(comp, ComparerCluster) else string
+
+            union = f" {where.restrictive[i + 1]} " if i != n - 1 else ""
+
+            condition += union
+            cond.append(condition)
+        return f" WHERE {"".join(cond)}"
+
+    def visit_having(self, having: Having) -> str:
+        assert (n := len(having.comparers)) == len(having.restrictive)
+
+        if not having.comparers:
+            return ""
+
+        cond = []
+
+        for i in range(n):
+            comp = having.comparers[i]
+
+            string = comp.compile(self.dialect).string
+
+            condition = f"({string})" if isinstance(comp, ComparerCluster) else string
+
+            union = f" {having.restrictive[i + 1]} " if i != n - 1 else ""
+
+            condition += union
+            cond.append(condition)
+        return f" HAVING {"".join(cond)}"
+
     def visit_join(self, join: JoinSelector) -> str:
         rt = join.rcon.table
         rtable = TableProxy(table_class=rt, path=join.rcon.path)
@@ -193,18 +253,191 @@ class MySQLCompiler(compiler.SQLCompiler):
     def visit_limit(self, limit: Limit, **kw):
         return f"LIMIT {limit._number}"
 
-    # TODOH []: include the rest of visit methods
-    def visit_insert(self, insert: Insert, **kw) -> str:
-        pass
+    # TODOH [x]: include the rest of visit methods
+    def visit_insert[T, TProp](self, insert: Insert) -> str:
+        def __is_valid[TProp](column: Column[TProp], value: TProp) -> bool:
+            """
+            We want to delete the column from table when it's specified with an 'AUTO_INCREMENT' or 'AUTO GENERATED ALWAYS AS (__) STORED' statement.
+
+            if the column is auto-generated, it means the database creates the value for that column, so we must deleted it.
+            if the column is primary key and auto-increment, we should be able to create an object with specific pk value.
+
+            RETURN
+            -----
+
+            - True  -> Do not delete the column from dict query
+            - False -> Delete the column from dict query
+            """
+
+            is_pk_none_and_auto_increment: bool = all([value is None, column.is_primary_key, column.is_auto_increment])
+
+            if is_pk_none_and_auto_increment or column.is_auto_generated:
+                return False
+            return True
+
+        def __fill_dict_list(list_dict: list[str, TProp], values: list[T]) -> list[Column]:
+            if isinstance(values, Iterable):
+                for x in values:
+                    __fill_dict_list(list_dict, x)
+
+            elif issubclass(values.__class__, Table):
+                new_list = []
+                for prop in type(values).__dict__.values():
+                    if not isinstance(prop, Column):
+                        continue
+
+                    value = getattr(values, prop.column_name)
+                    if __is_valid(prop, value):
+                        new_list.append(prop)
+                list_dict.append(new_list)
+
+            else:
+                raise Exception(f"Tipo de dato'{type(values)}' no esperado")
+            return None
+
+        if not isinstance(insert.values, Iterable):
+            values = (insert.values,)
+        else:
+            values = insert.values
+        valid_cols: list[list[Column]] = []
+        __fill_dict_list(valid_cols, values)
+
+        col_names: list[str] = []
+        wildcards: list[str] = []
+        col_values: list[list[str]] = []
+        for i, cols in enumerate(valid_cols):
+            col_values.append([])
+            CASTER = self.dialect.caster()
+            for col in cols:
+                clean_data = CASTER.for_column(col, insert.values[i])  # .resolve(insert.values[i][col])
+                if i == 0:
+                    col_names.append(col.column_name)
+                    wildcards.append(clean_data.wildcard_to_insert())
+                # COMMENT: avoid MySQLWriteCastBase.resolve when using PLACEHOLDERs
+                col_values[-1].append(clean_data.to_database)
+
+        join_cols = ", ".join(col_names)
+        unknown_rows = f"({', '.join(wildcards)})"  # The number of "%s" must match the dict 'dicc_0' length
+
+        insert.cleaned_values = [tuple(x) for x in col_values]
+        query = f"INSERT INTO {insert.table.__table_name__} {f'({join_cols})'} VALUES {unknown_rows}"
+        return query
 
     def visit_delete(self, delete: Delete, **kw) -> str:
-        pass
+        return f"DELETE FROM {delete.table.__table_name__}"
 
     def visit_upsert(self, upsert: Upsert, **kw) -> str:
-        pass
+        """
+        Generate MySQL UPSERT query using INSERT ... ON DUPLICATE KEY UPDATE.
+
+        Works with both single dictionaries and lists of changes. The function only
+        generates placeholders and column names - actual values are bound separately.
+
+        Parameters
+        ----------
+        upsert : Upsert
+            Upsert object containing table and values information
+
+        Returns
+        -------
+        str
+            SQL query string with placeholders
+
+        Examples
+        --------
+        Generated SQL:
+            INSERT INTO users (id, name, email)
+            VALUES (%s, %s, %s)
+            ON DUPLICATE KEY UPDATE
+                name = VALUES(name),
+                email = VALUES(email);
+
+        Actual execution with bound values:
+            [(1, 'Pablo', 'pablo@example.com'),
+            (2, 'Marina', 'marina@example.com')]
+
+        Notes
+        -----
+        - Primary key column is excluded from the UPDATE clause
+        - Uses MySQL's VALUES() function to reference inserted values
+        - For batch inserts, all rows must have the same column structure
+        """
+
+        # Generate the INSERT portion of the query
+        query_insert = self.visit_insert(upsert)
+
+        # MySQL uses VALUES() function to reference inserted values in UPDATE clause
+        VALUES_FUNCTION = "VALUES"
+
+        # Validate that we have values to work with
+        if not upsert.values or len(upsert.values) == 0:
+            raise ValueError("Upsert requires at least one value dictionary")
+
+        # Get column information from first value (all rows should have same structure)
+        first_value = upsert.values[0]
+        columns = first_value.get_columns()
+        pk_column = first_value.get_pk().column_name
+
+        # Build UPDATE clause: exclude primary key from updates
+        # Format: column = VALUES(column)
+        # fmt: off
+        update_columns = [
+            f"{col} = {VALUES_FUNCTION}({col})" 
+            for col in columns 
+            if col != pk_column
+        ]
+        # fmt: on
+
+        # Handle edge case: if only PK exists, nothing to update
+        if not update_columns:
+            raise ValueError(f"No columns to update besides primary key '{pk_column}'. " "UPSERT requires at least one non-PK column.")
+
+        update_clause = ", ".join(update_columns)
+
+        return f"{query_insert} ON DUPLICATE KEY UPDATE {update_clause};"
 
     def visit_update(self, update: Update, **kw) -> str:
-        pass
+        class UpdateKeyError(KeyError):
+            def __init__(self, table: Type[Table], key: str | ColumnType, *args):
+                super().__init__(*args)
+                self._table: Type[Table] = table
+                self._key: str | ColumnType = key
+
+            def __str__(self):
+                BASE_MSSG = lambda col: f"The column '{col}' does not belong to the table '{self._table.__table_name__}'"  # noqa: E731
+
+                if isinstance(self._key, Column):
+                    return BASE_MSSG(self._key.column_name) + f"; it belongs to the table '{self._key.table.__table_name__}'. Please check the columns in the query."
+                return BASE_MSSG(self._key) + ". Please check the columns in the query."
+
+        def __is_valid__(col: Column) -> bool:
+            if update.table is not col.table:
+                raise UpdateKeyError(update.table, col)
+            return not col.is_auto_generated
+
+        if not isinstance(update.values, dict):
+            raise TypeError
+
+        col_names: list[Column] = []
+        CASTER = self.dialect.caster()
+        for col, value in update.values.items():
+            if isinstance(col, str):
+                if not hasattr(update.table, col):
+                    raise UpdateKeyError(update.table, col)
+                col = getattr(update.table, col)
+            if not isinstance(col, Column | ColumnProxy):
+                raise ValueError
+
+            if __is_valid__(col):
+                clean_data = CASTER.for_value(value)
+                col_names.append((col.column_name, clean_data.wildcard_to_insert()))
+                update.cleaned_values.append(clean_data.to_database)
+
+        set_query: str = ",".join(["=".join(col_data) for col_data in col_names])
+
+        query = f"UPDATE {update.table.__table_name__} SET {set_query}"
+        update.cleaned_values = tuple(update.cleaned_values)
+        return query
 
     def visit_offset(self, offset: Offset, **kw) -> str:
         return f"OFFSET {offset._number}"
@@ -221,20 +454,6 @@ class MySQLCompiler(compiler.SQLCompiler):
 
         return ClauseInfo.concat_alias_and_column(f"COUNT({column})", count.alias)
 
-    def visit_where(self, where: Where) -> str:
-        from ormlambda.sql.comparer import Comparer
-
-        if not where.comparer:
-            return ""
-        cols = Comparer.join_comparers(list(where.comparer), restrictive=where.restrictive, dialect=self.dialect)
-        return f"WHERE {cols}"
-
-    def visit_having(self, having: Having) -> str:
-        from ormlambda.sql.comparer import Comparer
-
-        cols = Comparer.join_comparers(list(having.comparer), restrictive=having.restrictive, dialect=self.dialect, table=None, literal=True)
-        return f"HAVING {cols}"
-
     def visit_order(self, order: Order, **kw) -> str:
         ORDER = "ORDER BY"
         string_columns: list[str] = []
@@ -285,25 +504,60 @@ class MySQLCompiler(compiler.SQLCompiler):
         )
         return clause_info.query(self.dialect)
 
-    def visit_max(self, max: Max, **kw) -> str:
+    def visit_max(self, obj: Max, **kw) -> str:
+        return self._compile_aggregate_method("MAX", obj, **kw)
+
+    def visit_min(self, obj: Min, **kw) -> str:
+        return self._compile_aggregate_method("MIN", obj, **kw)
+
+    def visit_sum(self, obj: Sum, **kw) -> str:
+        return self._compile_aggregate_method("SUM", obj, **kw)
+
+    def visit_avg(self, obj: Avg, **kw) -> str:
+        return self._compile_aggregate_method("AVG", obj, **kw)
+
+    def visit_abs(self, obj: Abs, **kw) -> str:
+        return self._compile_aggregate_method("ABS", obj, **kw)
+
+    def visit_ceil(self, obj: Ceil, **kw) -> str:
+        return self._compile_aggregate_method("CEIL", obj, **kw)
+
+    def visit_floor(self, obj: Floor, **kw) -> str:
+        return self._compile_aggregate_method("FLOOR", obj, **kw)
+
+    def visit_round(self, obj: Round, **kw) -> str:
+        return self._compile_aggregate_method("ROUND", obj, **kw)
+
+    def visit_pow(self, obj: Pow, **kw) -> str:
         attr = {**kw, "alias_clause": None}
-        column = max.column.compile(self.dialect, **attr).string
-        return ClauseInfo.concat_alias_and_column(f"MAX({column})", max.alias)
+        column = obj.column.compile(self.dialect, **attr).string
+        return ClauseInfo.concat_alias_and_column(f"POW({column}, {obj._exponent})", obj.alias)
+
+    def visit_sqrt(self, obj: Sqrt, **kw) -> str:
+        return self._compile_aggregate_method("SQRT", obj, **kw)
+
+    def visit_mod(self, obj: Mod, **kw) -> str:
+        attr = {**kw, "alias_clause": None}
+        column = obj.column.compile(self.dialect, **attr).string
+        return ClauseInfo.concat_alias_and_column(f"MOD({column}, {obj._divisor})", obj.alias)
+
+    def visit_rand(self, obj: Rand, **kw) -> str:
+        return self._compile_aggregate_method("RAND", obj, **kw)
 
-    def visit_min(self, min: Min, **kw) -> str:
+    def visit_truncate(self, obj: Truncate, **kw) -> str:
         attr = {**kw, "alias_clause": None}
-        column = min.column.compile(self.dialect, **attr).string
-        return ClauseInfo.concat_alias_and_column(f"MIN({column})", min.alias)
+        column = obj.column.compile(self.dialect, **attr).string
+        return ClauseInfo.concat_alias_and_column(f"TRUNCATE({column}, {obj._decimal})", obj.alias)
 
-    def visit_sum(self, sum: Sum, **kw) -> str:
+    def _compile_aggregate_method(self, name: str, function: IFunction, **kw) -> str:
         attr = {**kw, "alias_clause": None}
-        column = sum.column.compile(self.dialect, **attr).string
-        return ClauseInfo.concat_alias_and_column(f"SUM({column})", sum.alias)
+        column = function.column.compile(self.dialect, **attr).string
+        return ClauseInfo.concat_alias_and_column(f"{name}({column})", function.alias)
 
     def visit_st_astext(self, st_astext: ST_AsText) -> str:
-        # avoid use placeholder when using IAggregate because no make sense.
+        # avoid use placeholder when using IFunction because no make sense.
         if st_astext.alias and (found := ClauseInfo._keyRegex.findall(st_astext.alias)):
-            raise NotKeysInIAggregateError(found)
+            raise NotKeysInIFunctionError(found)
         return ClauseInfo.concat_alias_and_column(f"ST_AsText({st_astext.column.compile(self.dialect, alias_clause=None).string})", st_astext.alias)
 
     def visit_st_contains(self, st_contains: ST_Contains) -> str:

{ormlambda-4.0.5 → ormlambda-4.4.0}/src/ormlambda/dialects/mysql/caster/types/iterable.py

@@ -29,4 +29,8 @@ class IterableCaster[TType](JsonCaster[TType]):
     @property
     @BaseCaster.return_value_if_exists
     def string_data(self) -> Optional[str]:
-        return str(self.value)
+        value = tuple(self.value) if not isinstance(self.value, tuple) else self.value
+
+        if len(value) == 1:
+            return f"({value[0]})"
+        return str(value)

{ormlambda-4.0.5 → ormlambda-4.4.0}/src/ormlambda/dialects/mysql/clauses/ST_AsText.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
-from ormlambda.sql.clause_info import IAggregate
+from ormlambda.sql.functions.interface import IFunction
 from ormlambda.sql.types import ColumnType, AliasType
 
 from ormlambda.sql.elements import ClauseElement
 
 
-class ST_AsText[T, TProp](ClauseElement, IAggregate):
+class ST_AsText[T, TProp](ClauseElement, IFunction):
     """
     https://dev.mysql.com/doc/refman/8.4/en/fetching-spatial-data.html
 

{ormlambda-4.0.5 → ormlambda-4.4.0}/src/ormlambda/dialects/mysql/clauses/ST_Contains.py

@@ -5,11 +5,11 @@ from shapely import Point
 
 from ormlambda import Column
 from ormlambda.sql.types import ColumnType, AliasType
-from ormlambda.sql.clause_info import IAggregate
+from ormlambda.sql.functions.interface import IFunction
 from ormlambda.sql.elements import ClauseElement
 
 
-class ST_Contains(ClauseElement, IAggregate):
+class ST_Contains(ClauseElement, IFunction):
     __visit_name__ = "st_contains"
 
     def __init__[TProp: Column](

{ormlambda-4.0.5 → ormlambda-4.4.0}/src/ormlambda/errors.py

@@ -17,10 +17,10 @@ class NoSuchModuleError(Exception):
         return f"NoSuchModuleError: {self.args[0]}"
 
 
-class DuplicatedClauseName(Exception):
+class DuplicatedClauseNameError(Exception):
     def __init__(self, names: tuple[str], **kw):
         self.names = names
         super().__init__(**kw)
 
     def __str__(self):
-        return f"Some clauses has the same alias. {self.names}\nTry wrapping the clause with the 'Alias' class first or setting 'avoid_duplicate' param as 'True'"
+        return f"Some clauses has the same alias. {self.names}\nTry wrapping the clause with the 'Alias' class first or setting 'avoid_duplicates' param as 'True'"

{ormlambda-4.0.5 → ormlambda-4.4.0}/src/ormlambda/repository/response.py

@@ -130,7 +130,8 @@ class Response[TFlavour, *Ts]:
             for i, data in enumerate(row):
                 alias = self._columns[i]
                 clause = self._select[alias]
-                parse_data = self._caster.for_value(data, value_type=clause.dtype).from_database
+                dtype = clause.dtype if hasattr(clause, "dtype") else None
+                parse_data = self._caster.for_value(data, value_type=dtype).from_database
                 new_row.append(parse_data)
             new_row = tuple(new_row)
             if not isinstance(new_row, tuple):

{ormlambda-4.0.5 → ormlambda-4.4.0}/src/ormlambda/sql/clause_info/__init__.py

@@ -1,2 +1 @@
-from .interface import IAggregate  # noqa: F401
 from .clause_info import ClauseInfo  # noqa: F401