ormlambda 3.35.3__py3-none-any.whl → 4.0.4__py3-none-any.whl

ormlambda/sql/clause_info/clause_info.py

@@ -1,23 +1,20 @@
 from __future__ import annotations
+from collections import defaultdict
 import typing as tp
 import re
 
-from ormlambda import Table
-from ormlambda import Column
-from ormlambda.sql.types import (
-    ASTERISK,
-    TableType,
-    ColumnType,
-    AliasType,
-    TypeEngine,
-)
+from ormlambda.sql.types import ASTERISK
+from ormlambda.errors import DuplicatedClauseName
 from .interface import IClauseInfo
-from ormlambda.sql import ForeignKey
+from ormlambda.common import GlobalChecker
+from ormlambda import util
 
 
-from .clause_info_context import ClauseInfoContext, ClauseContextType
-
 if tp.TYPE_CHECKING:
+    from ormlambda.sql import ForeignKey
+    from ormlambda import ColumnProxy
+    from ormlambda import Table
+    from ormlambda.sql.types import TableType, ColumnType, AliasType
     from ormlambda.dialects import Dialect
 
 
@@ -39,11 +36,9 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
     @tp.overload
     def __init__[TProp](self, table: TableType[T], column: ColumnType[TProp]): ...
     @tp.overload
-    def __init__[TProp](self, table: TableType[T], column: ColumnType[TProp], alias_table: AliasType[ClauseInfo[T]] = ..., alias_clause: AliasType[ClauseInfo[T]] = ...): ...
-    @tp.overload
-    def __init__(self, table: TableType[T], alias_table: AliasType[ClauseInfo[T]] = ..., alias_clause: AliasType[ClauseInfo[T]] = ...): ...
+    def __init__[TProp](self, table: TableType[T], column: ColumnType[TProp], alias_table: AliasType[ColumnProxy] = ..., alias_clause: AliasType[ColumnProxy] = ...): ...
     @tp.overload
-    def __init__[TProp](self, table: TableType[T], column: ColumnType[TProp], context: ClauseContextType): ...
+    def __init__(self, table: TableType[T], alias_table: AliasType[ColumnProxy] = ..., alias_clause: AliasType[ColumnProxy] = ...): ...
     @tp.overload
     def __init__(self, table: TableType[T], keep_asterisk: tp.Optional[bool] = ...): ...
     @tp.overload
@@ -58,12 +53,12 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         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,
+        alias_table: tp.Optional[AliasType[ColumnProxy]] = None,
+        alias_clause: tp.Optional[AliasType[ColumnProxy]] = None,
         keep_asterisk: bool = False,
         preserve_context: bool = False,
         dtype: tp.Optional[TProp] = None,
+        literal: bool = False,
         *,
         dialect: Dialect,
         **kw,
@@ -74,12 +69,12 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
 
         self._table: TableType[T] = table
         self._column: TableType[T] | ColumnType[TProp] = column
-        self._alias_table: tp.Optional[AliasType[ClauseInfo[T]]] = alias_table
-        self._alias_clause: tp.Optional[AliasType[ClauseInfo[T]]] = alias_clause
-        self._context: ClauseContextType = context if context else ClauseInfoContext()
+        self._alias_table: tp.Optional[AliasType[ColumnProxy]] = alias_table
+        self._alias_clause: tp.Optional[AliasType[ColumnProxy]] = alias_clause
         self._keep_asterisk: bool = keep_asterisk
         self._preserve_context: bool = preserve_context
         self._dtype = dtype
+        self._literal = literal
 
         self._dialect: Dialect = dialect
 
@@ -88,9 +83,6 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
             "table": self.replace_table_placeholder,
         }
 
-        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:
@@ -118,7 +110,7 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
 
     @property
     def alias_clause(self) -> tp.Optional[str]:
-        alias = self._alias_clause if not (a := self.get_clause_alias()) else a
+        alias = self._alias_clause
         return self._alias_resolver(alias)
 
     # TODOL [ ]: if we using this setter, we don't update the _context with the new value. Study if it's necessary
@@ -128,7 +120,7 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
 
     @property
     def alias_table(self) -> tp.Optional[str]:
-        alias = self._alias_table if not (a := self.get_table_alias()) else a
+        alias = self._alias_table
         return self._alias_resolver(alias)
 
     # TODOL [ ]: if we using this setter, we don't update the _context with the new value. Study if it's necessary
@@ -147,20 +139,12 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
     def unresolved_column(self) -> ColumnType:
         return self._column
 
-    @property
-    def context(self) -> ClauseContextType:
-        return self._context
-
-    @context.setter
-    def context(self, value: ClauseInfoContext) -> None:
-        self._context = value
-
     @property
     def dtype[TProp](self) -> tp.Optional[tp.Type[TProp]]:
         if self._dtype is not None:
             return self._dtype
 
-        if isinstance(self._column, Column):
+        if self.is_column(self._column):
             return self._column.dtype
 
         if isinstance(self._column, type):
@@ -182,6 +166,9 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
     def query(self, dialect: Dialect, **kwargs) -> str:
         return self._create_query(dialect, **kwargs)
 
+    def compile(self, dialect: Dialect, **kwargs) -> str:
+        return self._create_query(dialect, **kwargs)
+
     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:
@@ -190,26 +177,29 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         if not self.table and self._alias_clause:
             # it means that we are passing an object with alias. We should delete '' around the object
             alias_clause = self.alias_clause
-            return self._concat_alias_and_column(self._column, alias_clause)
+            return self.concat_alias_and_column(self._column, alias_clause)
 
         # When passing the Table itself without 'column'
         if self.table and not self._column:
             if not self._alias_table:
                 return self.table.__table_name__
             alias_table = self.alias_table
-            return self._concat_alias_and_column(self.table.__table_name__, alias_table)
+            return self.concat_alias_and_column(self.table.__table_name__, alias_table)
 
         if self._return_all_columns():
-            return self._get_all_columns()
-        return self._join_table_and_column(self._column)
+            return self._get_all_columns(dialect)
+        return self._join_table_and_column(self._column, dialect)
 
-    def _join_table_and_column[TProp](self, column: ColumnType[TProp]) -> str:
-        # FIXME [x]: Study how to deacoplate from mysql database
+    @util.preload_module("ormlambda.sql")
+    def _join_table_and_column[TProp](self, column: ColumnType[TProp], dialect: Dialect) -> str:
+        ColumnProxy = util.preloaded.sql_column.ColumnProxy
 
-        caster = self._dialect.caster()
+        caster = dialect.caster()
 
         if self.alias_table:
-            table = self._wrapped_with_quotes(self.alias_table)
+            table = self.wrapped_with_quotes(self.alias_table)
+        elif isinstance(column, ColumnProxy):
+            table = self.wrapped_with_quotes(column.get_table_chain())
         else:
             table = self.table.__table_name__
 
@@ -219,7 +209,7 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
 
         dtype = str if self.is_table(self.dtype) else self.dtype
         wrapped_column = caster.for_value(table_column, dtype).wildcard_to_select(table_column)
-        return self._concat_alias_and_column(wrapped_column, self.alias_clause)
+        return self.concat_alias_and_column(wrapped_column, self.alias_clause)
 
     def _return_all_columns(self) -> bool:
         if self._keep_asterisk:
@@ -234,22 +224,21 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
     def is_asterisk(value: tp.Optional[str]) -> bool:
         return isinstance(value, str) and value == ASTERISK
 
-    def _get_all_columns(self) -> str:
+    def _get_all_columns(self, dialect: Dialect) -> str:
         def ClauseCreator(column: str) -> ClauseInfo:
             return ClauseInfo(
                 table=self.table,
                 column=column,
                 alias_table=self._alias_table,
                 alias_clause=self._alias_clause,
-                context=self._context,
                 keep_asterisk=self._keep_asterisk,
-                dialect=self._dialect,
+                dialect=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)
+            return self._join_table_and_column(ASTERISK, dialect)
 
-        columns: list[ClauseInfo] = [ClauseCreator(column).query(self._dialect) for column in self.table.get_columns()]
+        columns: list[ClauseInfo] = [ClauseCreator(column).query(dialect) for column in self.table.get_columns()]
 
         return ", ".join(columns)
 
@@ -261,7 +250,7 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         if isinstance(column, tp.Iterable) and isinstance(column[0], ClauseInfo):
             return self.join_clauses(column)
 
-        if isinstance(column, Column):
+        if self.is_column(column):
             return column.column_name
 
         # if we want to pass the name of a column as a string, the 'table' var must not be None
@@ -281,6 +270,10 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         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.
+            if self._literal:
+                # That condition will be used when you need to pass a value without wrapped in any quote like using HAVING clause
+                # COMMENT: Check 'test_complex_1' test
+                return casted_value.value
             return casted_value.string_data
         return casted_value.wildcard_to_select()
 
@@ -295,48 +288,63 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
 
         return func(self._column)
 
-    def _concat_alias_and_column(self, column: str, alias_clause: tp.Optional[str] = None) -> str:
+    @classmethod
+    def concat_alias_and_column(cls, column: str, alias_clause: tp.Optional[str] = None) -> str:
         if alias_clause is None:
             return column
-        alias = f"{column} AS {self._wrapped_with_quotes(alias_clause)}"
+        alias = f"{column} AS {cls.wrapped_with_quotes(alias_clause)}"
         return alias
 
-    def _alias_resolver(self, alias: AliasType[ClauseInfo[T]]) -> tp.Optional[str]:
+    def _alias_resolver(self, alias: AliasType[ColumnProxy]) -> tp.Optional[str]:
         if alias is None:
             return None
 
         if callable(alias):
-            return self._alias_resolver(alias(self))
+            return self._alias_resolver(alias(self._column))
 
         return self._replace_placeholder(alias)
 
-    def get_clause_alias(self) -> tp.Optional[str]:
-        if not self._context:
-            return None
-        return self._context.get_clause_alias(self)
-
-    def get_table_alias(self) -> tp.Optional[str]:
-        if not self._context:
-            return None
-        return self._context.get_table_alias(self.table)
-
     @staticmethod
-    def join_clauses(clauses: list[ClauseInfo[T]], chr: str = ",", context: tp.Optional[ClauseInfoContext] = None, *, dialect: Dialect) -> str:
+    def join_clauses(clauses: list[ColumnProxy], chr: str = ",", *, dialect: Dialect, **kw) -> str:
+        raise_alias_duplicated = False
+        all_aliases: dict[str, int] = defaultdict(int)
         queries: list[str] = []
         for c in clauses:
-            if context:
-                c.context = context
-                c._dialect = dialect
-            queries.append(c.query(dialect))
+            # That update control the alias we set by default on select clause
+            if "alias_clause" in kw:
+                alias_clause = kw["alias_clause"]
+            elif c.alias:
+                alias_clause = c.alias
+            else:
+                alias_clause = c.column_name
 
+            param = {**kw, "alias_clause": alias_clause}
+            compiled = c.compile(dialect, **param)
+
+            # FIXME [ ]: we use c.alias because we're modifying dynamically when compile the object insdie 'visit_column_proxy' method
+            # it's working right though it's not the way to do it.
+            NEW_ALIAS = c.alias
+            all_aliases[NEW_ALIAS] += 1
+
+            if all_aliases[NEW_ALIAS] > 1:
+                raise_alias_duplicated = True
+
+            queries.append(compiled.string)
+
+        if raise_alias_duplicated:
+            raise DuplicatedClauseName(tuple(alias for alias, number in all_aliases.items() if number > 1))
         return f"{chr} ".join(queries)
 
     @staticmethod
-    def _wrapped_with_quotes(string: str) -> str:
-        return f"`{string}`"
+    def wrapped_with_quotes(
+        string: str,
+        first: str = GlobalChecker.FIRST_QUOTE,
+        end: str = GlobalChecker.END_QUOTE,
+    ) -> str:
+        return f"{first}{string}{end}"
 
     @classmethod
-    def extract_table(cls, element: ColumnType[T] | TableType[T]) -> tp.Optional[T]:
+    def extract_table(cls, element: ForeignKey | ColumnType[T] | TableType[T]) -> tp.Optional[T]:
         if element is None:
             return None
 
@@ -346,22 +354,32 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
         if cls.is_foreign_key(element):
             return element.tright
 
-        if isinstance(element, Column):
+        if cls.is_column(element):
             return element.table
         return None
 
+    @util.preload_module("ormlambda.sql")
     @staticmethod
     def is_table(data: ColumnType | Table | ForeignKey) -> bool:
-        return isinstance(data, type) and issubclass(data, Table)
+        Table = util.preloaded.sql_table.Table
+        TableProxy = util.preloaded.sql_table.TableProxy
+        
+        return isinstance(data, type) and issubclass(data, Table | TableProxy)
 
+    @util.preload_module("ormlambda.sql")
     @staticmethod
     def is_foreign_key(data: ColumnType | Table | ForeignKey) -> bool:
+        ForeignKey = util.preloaded.sql_foreign_key.ForeignKey
         return isinstance(data, ForeignKey)
 
+    @util.preload_module("ormlambda.sql")
     @classmethod
     def is_column(cls, data: tp.Any) -> bool:
+        Column = util.preloaded.sql_column.Column
+        ColumnProxy = util.preloaded.sql_column.ColumnProxy
+
         if cls.is_table(data) or cls.is_foreign_key(data) or cls.is_asterisk(data):
             return False
-        if isinstance(data, Column):
+        if isinstance(data, Column | ColumnProxy):
             return True
         return False

ormlambda/sql/clause_info/interface/IAggregate.py

@@ -1,10 +1,20 @@
 from __future__ import annotations
 import abc
+from typing import Any, Iterable, TYPE_CHECKING
 
-from ormlambda.common.interfaces.IQueryCommand import IQuery
+if TYPE_CHECKING:
+    from ormlambda import ColumnProxy
 
 
-class IAggregate(IQuery):
-    @classmethod
+class IAggregate():
+    alias: str
+
+    def __repr__(self):
+        return f"{IAggregate.__name__}: {type(self).__name__}"
+
+    @abc.abstractmethod
+    def used_columns(self) -> Iterable[ColumnProxy]: ...
+
+    @property
     @abc.abstractmethod
-    def FUNCTION_NAME(cls) -> str: ...
+    def dtype(self) -> Any: ...

ormlambda/sql/clause_info/interface/IClauseInfo.py

@@ -1,16 +1,14 @@
 from __future__ import annotations
 import abc
-import typing as tp
-
-from ormlambda import Table
+from typing import Optional, Type, TYPE_CHECKING
 from ormlambda.common.interfaces.IQueryCommand import IQuery
 from ormlambda.sql.types import (
     TableType,
     ColumnType,
 )
 
-
-from ..clause_info_context import ClauseContextType
+if TYPE_CHECKING:
+    from ormlambda import Table
 
 
 class IClauseInfo[T: Table](IQuery):
@@ -19,10 +17,10 @@ class IClauseInfo[T: Table](IQuery):
     def table(self) -> TableType[T]: ...
     @property
     @abc.abstractmethod
-    def alias_clause(self) -> tp.Optional[str]: ...
+    def alias_clause(self) -> Optional[str]: ...
     @property
     @abc.abstractmethod
-    def alias_table(self) -> tp.Optional[str]: ...
+    def alias_table(self) -> Optional[str]: ...
     @property
     @abc.abstractmethod
     def column(self) -> str: ...
@@ -31,7 +29,4 @@ class IClauseInfo[T: Table](IQuery):
     def unresolved_column(self) -> ColumnType: ...
     @property
     @abc.abstractmethod
-    def context(self) -> ClauseContextType: ...
-    @property
-    @abc.abstractmethod
-    def dtype[TProp](self) -> tp.Optional[tp.Type[TProp]]: ...
+    def dtype[TProp](self) -> Optional[Type[TProp]]: ...

ormlambda/sql/clauses/alias.py

@@ -1,45 +1,14 @@
 from __future__ import annotations
-import typing as tp
 
-from ormlambda.sql.clause_info import ClauseInfo
-from ormlambda.sql.elements import ClauseElement
+from ormlambda import ColumnProxy
 
 
-if tp.TYPE_CHECKING:
-    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](ColumnProxy[T]):
+    def __init__(self, column: ColumnProxy[T], alias: str):
+        super().__init__(column._column, path=column.path, alias=alias)
 
-
-class Alias[T: Table](ClauseInfo[T], ClauseElement):
-    __visit_name__ = "alias"
-
-    def __init__[TProp](
-        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,
-        **kw,
-    ):
-        if not alias_clause:
-            raise TypeError
-        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,
-        )
+    def __repr__(self):
+        return f"{Alias.__name__}: {super().__repr__()}"
 
 
 __all__ = ["Alias"]

ormlambda/sql/clauses/count.py

@@ -1,57 +1,42 @@
 from __future__ import annotations
-from ormlambda.sql.clause_info import AggregateFunctionBase
-from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+from ormlambda.sql.clause_info import IAggregate
 
-from ormlambda.sql.types import AliasType, ColumnType
+from ormlambda.sql.types import ColumnType
 
 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
+    from ormlambda.sql.types import ColumnType, TableType
 
 
-class Count[T: Table](AggregateFunctionBase[T], ClauseElement):
+class Count[T: Table](ClauseElement, IAggregate):
     __visit_name__ = "count"
 
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "COUNT"
-
-    def __init__[TProp: Table](
+    def __init__[TProp](
         self,
-        element: ColumnType[T] | TableType[TProp],
-        alias_table: AliasType[ColumnType[TProp]] = None,
-        alias_clause: AliasType[ColumnType[TProp]] = "count",
-        context: ClauseContextType = None,
-        keep_asterisk: bool = True,
-        preserve_context: bool = True,
-        *,
-        dialect: Dialect,
-        **kw,
+        element: str | ColumnType[TProp] | TableType[T] = "*",
+        alias: str = "count",
     ) -> None:
-        table = self.extract_table(element)
-        column = element if self.is_column(element) else ASTERISK
-
-        super().__init__(
-            table=table if (alias_table or (context and table in context._table_context)) else None,
-            column=column,
-            alias_table=alias_table,
-            alias_clause=alias_clause,
-            context=context,
-            keep_asterisk=keep_asterisk,
-            preserve_context=preserve_context,
-            dtype=int,
-            dialect=dialect,
-            **kw,
-        )
+        self.column = element
+        self.alias = alias
+
+    @property
+    def dtype(self) -> str:
+        return int
+
+    def used_columns(self) -> tp.Iterable:
+        if isinstance(self.column, str):
+            # If is str, probably will by because we're using * so we don't have to retrieve something
+            return []
+        if not isinstance(self.column, tp.Iterable):
+            return [self.column]
+        return self.column
 
 
 __all__ = ["Count"]

ormlambda/sql/clauses/group_by.py

@@ -1,30 +1,24 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
+from typing import Any, Iterable
+
+from ormlambda.sql.clause_info import IAggregate
 
-if TYPE_CHECKING:
-    from ormlambda.dialects import Dialect
-from ormlambda.sql.clause_info import AggregateFunctionBase, ClauseInfoContext
 from ormlambda.sql.types import ColumnType
 from ormlambda.sql.elements import ClauseElement
 
 
-class GroupBy(AggregateFunctionBase, ClauseElement):
+class GroupBy(ClauseElement, IAggregate):
     __visit_name__ = "group_by"
 
-    @classmethod
-    def FUNCTION_NAME(self) -> str:
-        return "GROUP BY"
-
-    def __init__(self, column: ColumnType, context: ClauseInfoContext, dialect: Dialect, **kwargs):
-        super().__init__(
-            table=column.table,
-            column=column,
-            alias_table=None,
-            alias_clause=None,
-            context=context,
-            dialect=dialect,
-            **kwargs,
-        )
+    def __init__(self, *column: ColumnType):
+        self.column: tuple[ColumnType] = column if isinstance(column, Iterable) else [column]
+
+    def used_columns(self):
+        return self.column
+
+    @property
+    def dtype(self) -> Any:
+        return ...
 
 
 __all__ = ["GroupBy"]

ormlambda/sql/clauses/having.py

@@ -10,12 +10,8 @@ class Having(Where):
 
     __visit_name__ = "having"
 
-    def __init__(self, *comparer, restrictive=True, context=None, **kw):
-        super().__init__(*comparer, restrictive=restrictive, context=context, **kw)
-
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "HAVING"
+    def __init__(self, *comparer, restrictive=True, **kw):
+        super().__init__(*comparer, restrictive=restrictive, **kw)
 
 
 __all__ = ["Having"]

ormlambda/sql/clauses/insert.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import override, Iterable, TYPE_CHECKING
 
 from ormlambda import Table
-from ormlambda import Column
+from ormlambda import Column, ColumnProxy
 
 from ormlambda.sql.clauses.interfaces import IInsert
 from ormlambda.common.abstract_classes import NonQueryBase
@@ -53,7 +53,7 @@ class Insert[T: Table, TRepo](NonQueryBase[T, TRepo], IInsert[T], ClauseElement)
                 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
+        unknown_rows = f"({', '.join(wildcards)})"  # The number of "%s" must match the dict 'dicc_0' length
 
         self._values = [tuple(x) for x in col_values]
         self._query = f"{self.CLAUSE} {self._model.__table_name__} {f'({join_cols})'} VALUES {unknown_rows}"
@@ -88,7 +88,7 @@ class Insert[T: Table, TRepo](NonQueryBase[T, TRepo], IInsert[T], ClauseElement)
         elif issubclass(values.__class__, Table):
             new_list = []
             for prop in type(values).__dict__.values():
-                if not isinstance(prop, Column):
+                if not isinstance(prop, Column | ColumnProxy):
                     continue
 
                 value = getattr(values, prop.column_name)

ormlambda/sql/clauses/interfaces/__init__.py

@@ -1,5 +1,4 @@
 from .IDelete import IDelete  # noqa: F401
 from .IInsert import IInsert  # noqa: F401
-from .ISelect import ISelect  # noqa: F401
 from .IUpdate import IUpdate  # noqa: F401
 from .IUpsert import IUpsert  # noqa: F401