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

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

@@ -3,20 +3,24 @@ from collections import defaultdict
 from typing import override, Optional, TYPE_CHECKING, Type
 
 
-from ormlambda.utils.module_tree.dfs_traversal import DFSTraversal
+from ormlambda.util.module_tree.dfs_traversal import DFSTraversal
 from ormlambda.common.interfaces.IJoinSelector import IJoinSelector
 from ormlambda.common.interfaces.IQueryCommand import IQuery
 from ormlambda import JoinType
 from ormlambda.sql.clause_info import ClauseInfo
 from ormlambda.sql.comparer import Comparer
 from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
+from ormlambda.sql.elements import ClauseElement
+
 
 # TODOL [x]: Try to import Table module without circular import Error
 if TYPE_CHECKING:
     from ormlambda import Table
+    from ormlambda.dialects import Dialect
 
 
-class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight]):
+class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight], ClauseElement):
+    __visit_name__ = "join"
     __slots__: tuple = (
         "_comparer",
         "_orig_table",
@@ -37,26 +41,31 @@ class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight]):
 
     def __init__[LProp, RProp](
         self,
-        where: Comparer[TLeft, LProp, TRight, RProp],
+        where: Comparer,
         by: JoinType,
         alias: Optional[str] = "{table}",
         context: ClauseContextType = None,
+        *,
+        dialect: Dialect,
+        **kw,
     ) -> None:
-        self._comparer: Comparer[TLeft, LProp, TRight, RProp] = where
-        self._orig_table: TLeft = where.left_condition.table
-        self._right_table: TRight = where.right_condition.table
+        lcon = where.left_condition(dialect)
+        rcon = where.right_condition(dialect)
+        self._comparer: Comparer = where
+        self._orig_table: TLeft = lcon.table
+        self._right_table: TRight = rcon.table
         self._by: JoinType = by
-        self._left_col: str = where.left_condition._column.column_name
-        self._right_col: str = where.right_condition._column.column_name
+        self._left_col: str = lcon._column.column_name
+        self._right_col: str = rcon._column.column_name
         self._compareop = where._compare
         self._context: ClauseContextType = context if context else ClauseInfoContext()
 
         # COMMENT: When multiple columns reference the same table, we need to create an alias to maintain clear references.
         self._alias: Optional[str] = alias
 
-        self._from_clause = ClauseInfo(self.right_table, alias_table=alias, context=self._context)
-        self._left_table_clause = ClauseInfo(self.left_table, column=self.left_col, alias_clause=None, context=self._create_partial_context())
-        self._right_table_clause = ClauseInfo(self.right_table, column=self.right_col, alias_clause=None, context=self._create_partial_context())
+        self._from_clause = ClauseInfo(self.right_table, alias_table=alias, context=self._context, dialect=dialect, **kw)
+        self._left_table_clause = ClauseInfo(self.left_table, column=self.left_col, alias_clause=None, context=self._create_partial_context(), dialect=dialect, **kw)
+        self._right_table_clause = ClauseInfo(self.right_table, column=self.right_col, alias_clause=None, context=self._create_partial_context(), dialect=dialect, **kw)
 
     def __eq__(self, __value: JoinSelector) -> bool:
         return isinstance(__value, JoinSelector) and self.__hash__() == __value.__hash__()
@@ -82,20 +91,18 @@ class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight]):
         return ClauseInfoContext(clause_context=None, table_context=self._context._table_context)
 
     @classmethod
-    def join_selectors(cls, *args: JoinSelector) -> str:
-        return "\n".join([x.query for x in args])
+    def join_selectors(cls, dialect: Dialect, *args: JoinSelector) -> str:
+        return "\n".join([x.query(dialect) for x in args])
 
-    @property
-    @override
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         self._context = ClauseInfoContext(clause_context=None, table_context=self._context._table_context)
         list_ = [
             self._by.value,  # inner join
-            self._from_clause.query,
+            self._from_clause.query(dialect, **kwargs),
             "ON",
-            self._left_table_clause.query,
+            self._left_table_clause.query(dialect, **kwargs),
             self._compareop,  # =
-            self._right_table_clause.query,
+            self._right_table_clause.query(dialect, **kwargs),
         ]
         return " ".join([x for x in list_ if x is not None])
 
@@ -147,3 +154,6 @@ class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight]):
                 continue
             res.extend(tables)
         return res
+
+
+__all__ = ["JoinSelector"]

ormlambda/sql/clauses/limit.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from ormlambda.sql.elements import ClauseElement
+
+
+class Limit(ClauseElement):
+    __visit_name__ = "limit"
+    LIMIT = "LIMIT"
+
+    def __init__(self, number: int, **kwargs) -> None:
+        if not isinstance(number, int):
+            raise ValueError
+        self._number: int = number
+
+
+__all__ = ["Limit"]

ormlambda/sql/clauses/offset.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from ormlambda.sql.elements import ClauseElement
+
+
+class Offset(ClauseElement):
+    __visit_name__ = "offset"
+    OFFSET = "OFFSET"
+
+    def __init__(self, number: int, **kwargs) -> None:
+        if not isinstance(number, int):
+            raise ValueError
+        self._number: int = number
+
+
+__all__ = ["Offset"]

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

@@ -1,14 +1,20 @@
 from __future__ import annotations
 import typing as tp
 
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
+from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
 from ormlambda.sql.types import ColumnType
 from ormlambda.sql.clause_info import AggregateFunctionBase
 
 from ormlambda.statements import OrderType
+from ormlambda.sql.elements import ClauseElement
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
+
+class Order(AggregateFunctionBase, ClauseElement):
+    __visit_name__ = "order"
 
-class Order(AggregateFunctionBase):
     @staticmethod
     def FUNCTION_NAME() -> str:
         return "ORDER BY"
@@ -18,11 +24,16 @@ class Order(AggregateFunctionBase):
         column: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
         order_type: tp.Iterable[OrderType],
         context: ClauseContextType = None,
+        *,
+        dialect: Dialect,
+        **kw,
     ):
         super().__init__(
             table=None,
             column=column,
             context=context,
+            dialect=dialect,
+            **kw,
         )
 
         if isinstance(order_type, str) or not isinstance(order_type, tp.Iterable):
@@ -41,25 +52,4 @@ class Order(AggregateFunctionBase):
                 pass
         raise Exception(f"order_type param only can be 'ASC' or 'DESC' string or '{OrderType.__name__}' enum")
 
-    @tp.override
-    @property
-    def query(self) -> str:
-        string_columns: list[str] = []
-        columns = self.unresolved_column
-
-        # if this attr is not iterable means that we only pass one column without wrapped in a list or tuple
-        if isinstance(columns, str):
-            string_columns = f"{columns} {str(self._order_type[0])}"
-            return f"{self.FUNCTION_NAME()} {string_columns}"
-
-        if not isinstance(columns, tp.Iterable):
-            columns = (columns,)
-
-        assert len(columns) == len(self._order_type)
-
-        context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
-        for index, clause in enumerate(self._convert_into_clauseInfo(columns, context)):
-            clause.alias_clause = None
-            string_columns.append(f"{clause.query} {str(self._order_type[index])}")
-
-        return f"{self.FUNCTION_NAME()} {', '.join(string_columns)}"
+__all__ = ["Order"]

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

@@ -1,17 +1,20 @@
 from __future__ import annotations
-from typing import Optional, override, Type, Callable, TYPE_CHECKING
+from ormlambda.sql.elements import ClauseElement
+from typing import Optional, Type, Callable, TYPE_CHECKING
 
 from ormlambda.sql.clause_info import ClauseInfo
 from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
 from ormlambda.sql.types import AliasType
 from ormlambda.common.abstract_classes.decomposition_query import DecompositionQueryBase
-from ormlambda.components import ISelect
 
 if TYPE_CHECKING:
     from ormlambda import Table
+    from ormlambda.dialects import Dialect
 
 
-class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ISelect):
+class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ClauseElement):
+    __visit_name__ = "select"
+
     CLAUSE: str = "SELECT"
 
     def __init__(
@@ -21,12 +24,14 @@ class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ISelect):
         *,
         alias_table: AliasType[ClauseInfo] = "{table}",
         context: Optional[ClauseInfoContext] = None,
+        dialect: Dialect,
         **kwargs,
     ) -> None:
         super().__init__(
             tables,
             columns,
             context=context,
+            dialect=dialect,
             **kwargs,
         )
         self._alias_table = alias_table
@@ -35,18 +40,12 @@ class Select[T: Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ISelect):
 
     @property
     def FROM(self) -> ClauseInfo[T]:
-        return ClauseInfo(self.table, None, alias_table=self._alias_table, context=self._context)
+        return ClauseInfo(self.table, None, alias_table=self._alias_table, context=self._context, dialect=self._dialect, **self.kwargs)
 
     @property
     def COLUMNS(self) -> str:
-        return ClauseInfo.join_clauses(self._all_clauses, ",", self.context)
+        dialect = self.kwargs.pop("dialect", self._dialect)
+        return ClauseInfo.join_clauses(self._all_clauses, ",", self.context, dialect=dialect)
 
-    # TODOL: see who to deal when we will have to add more mysql methods
-    @override
-    @property
-    def query(self) -> str:
-        # COMMENT: (select.query, query)We must first create an alias for 'FROM' and then define all the remaining clauses.
-        # This order is mandatory because it adds the clause name to the context when accessing the .query property of 'FROM'
-        FROM = self.FROM
 
-        return f"{self.CLAUSE} {self.COLUMNS} FROM {FROM.query}"
+__all__ = ["Select"]

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

@@ -1,11 +1,18 @@
-from typing import Type, override, Any
+from __future__ import annotations
+from typing import Type, override, Any, TYPE_CHECKING, Optional
 
-from ormlambda.components.update import UpdateQueryBase
 from ormlambda import Table, Column
-from ormlambda.repository import IRepositoryBase
 from ormlambda.caster.caster import Caster
 from .where import Where
-from ormlambda.sql.types import ColumnType
+from ormlambda.common.abstract_classes import NonQueryBase
+from .interfaces import IUpdate
+
+if TYPE_CHECKING:
+    from ormlambda.sql.types import ColumnType
+    from .where import Where
+    from ormlambda.engine import Engine
+
+from ormlambda.sql.elements import ClauseElement
 
 
 class UpdateKeyError(KeyError):
@@ -20,9 +27,12 @@ class UpdateKeyError(KeyError):
         return f"The column '{self._key}' does not belong to the table '{self._table.__table_name__}'. Please check the columns in the query."
 
 
-class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase]):
-    def __init__(self, model: T, repository: Any, where: list[Where]) -> None:
-        super().__init__(model, repository, where)
+class Update[T: Type[Table], TRepo](NonQueryBase[T, TRepo], IUpdate, ClauseElement):
+    __visit_name__ = "update"
+
+    def __init__(self, model: T, repository: Any, where: list[Where], engine: Engine) -> None:
+        super().__init__(model, repository, engine=engine)
+        self._where: Optional[list[Where]] = where
 
     @override
     @property
@@ -33,11 +43,11 @@ class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase]):
     def execute(self) -> None:
         if self._where:
             for where in self._where:
-                query_with_table = where.query
+                query_with_table = where.query(self._engine.dialect)
                 for x in where._comparer:
                     # TODOH []: Refactor this part. We need to get only the columns withouth __table_name__ preffix
-                    self._query += " " + query_with_table.replace(x.left_condition.table.__table_name__ + ".", "")
-        return self._repository.execute_with_values(self._query, self._values)
+                    self._query += " " + query_with_table.replace(x.left_condition(self._dialect).table.__table_name__ + ".", "")
+        return self._engine.repository.execute_with_values(self._query, self._values)
 
     @override
     def update[TProp](self, dicc: dict[str | ColumnType[TProp], Any]) -> None:
@@ -45,7 +55,7 @@ class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase]):
             raise TypeError
 
         col_names: list[Column] = []
-        CASTER = Caster(self._repository)
+        CASTER = self._engine.dialect.caster()
         for col, value in dicc.items():
             if isinstance(col, str):
                 if not hasattr(self._model, col):
@@ -69,3 +79,6 @@ class UpdateQuery[T: Type[Table]](UpdateQueryBase[T, IRepositoryBase]):
         if self._model is not col.table:
             raise UpdateKeyError(self._model, col)
         return not col.is_auto_generated
+
+
+__all__ = ["Update"]

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

@@ -1,20 +1,22 @@
 from __future__ import annotations
 from typing import override, TYPE_CHECKING
 
-from ormlambda import Table
-from ormlambda.components.upsert import UpsertQueryBase
-from ormlambda.repository import IRepositoryBase, BaseRepository
+if TYPE_CHECKING:
+    from ormlambda.engine import Engine
 
+from ormlambda import Table
+from ormlambda.repository import BaseRepository
+from ormlambda.sql.clauses.interfaces import IUpsert
+from ormlambda.common.abstract_classes import NonQueryBase
+from .insert import Insert
+from ormlambda.sql.elements import ClauseElement
 
-from .insert import InsertQuery
 
-if TYPE_CHECKING:
-    from mysql.connector import MySQLConnection
+class Upsert[T: Table, TRepo](NonQueryBase[T, TRepo], IUpsert[T], ClauseElement):
+    __visit_name__ = "upsert"
 
-
-class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase]):
-    def __init__(self, model: T, repository: BaseRepository[MySQLConnection]) -> None:
-        super().__init__(model, repository)
+    def __init__(self, model: T, repository: BaseRepository[TRepo], engine: Engine) -> None:
+        super().__init__(model, repository, engine=engine)
 
     @override
     @property
@@ -23,7 +25,7 @@ class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase]):
 
     @override
     def execute(self) -> None:
-        return self._repository.executemany_with_values(self._query, self._values)
+        return self._engine.repository.executemany_with_values(self._query, self._values)
 
     @override
     def upsert(self, instances: T | list[T]) -> None:
@@ -54,7 +56,7 @@ class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase]):
         COL2 = _val.COL2;
 
         """
-        insert = InsertQuery[T](self._model, self._repository)
+        insert = Insert(self._model, self._engine.repository, self._engine.dialect)
         insert.insert(instances)
 
         if isinstance(instances, Table):
@@ -70,3 +72,6 @@ class UpsertQuery[T: Table](UpsertQueryBase[T, IRepositoryBase]):
         self._query = query
         self._values = insert.values
         return None
+
+
+__all__ = ["Upsert"]

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

@@ -3,14 +3,25 @@ import typing as tp
 from ormlambda.sql.comparer import Comparer
 from ormlambda.sql.clause_info import AggregateFunctionBase
 from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
+from ormlambda.sql.elements import ClauseElement
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
 
-class Where(AggregateFunctionBase):
+
+class Where(AggregateFunctionBase, ClauseElement):
     """
     The purpose of this class is to create 'WHERE' condition queries properly.
     """
 
-    def __init__(self, *comparer: Comparer, restrictive: bool = True, context: ClauseContextType = None) -> None:
+    __visit_name__ = "where"
+
+    def __init__(
+        self,
+        *comparer: Comparer,
+        restrictive: bool = True,
+        context: ClauseContextType = None,
+    ) -> None:
         self._comparer: tuple[Comparer] = comparer
         self._restrictive: bool = restrictive
         self._context: ClauseContextType = context if context else ClauseInfoContext()
@@ -19,11 +30,16 @@ class Where(AggregateFunctionBase):
     def FUNCTION_NAME() -> str:
         return "WHERE"
 
-    @property
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         if isinstance(self._comparer, tp.Iterable):
             context = ClauseInfoContext(table_context=self._context._table_context)
-            comparer = Comparer.join_comparers(self._comparer, restrictive=self._restrictive, context=context)
+            comparer = Comparer.join_comparers(
+                self._comparer,
+                restrictive=self._restrictive,
+                context=context,
+                dialect=dialect,
+                **kwargs,
+            )
         else:
             comparer = self._comparer
         return f"{self.FUNCTION_NAME()} {comparer}"
@@ -33,13 +49,17 @@ class Where(AggregateFunctionBase):
         return None
 
     @classmethod
-    def join_condition(cls, wheres: tp.Iterable[Where], restrictive: bool, context: ClauseInfoContext) -> str:
+    def join_condition(cls, wheres: tp.Iterable[Where], restrictive: bool, context: ClauseInfoContext, dialect: Dialect = None) -> str:
         if not isinstance(wheres, tp.Iterable):
             wheres = (wheres,)
 
         comparers: list[Comparer] = []
         for where in wheres:
             for c in where._comparer:
-                c.set_context(context)
+                if not c._context:
+                    c._context = context
                 comparers.append(c)
-        return cls(*comparers, restrictive=restrictive, context=context).query
+        return cls(*comparers, restrictive=restrictive, context=context).query(dialect=dialect)
+
+
+__all__ = ["Where"]

ormlambda/sql/column/__init__.py

@@ -0,0 +1 @@
+from .column import Column  # noqa: F401

ormlambda/sql/{column.py → column/column.py}

@@ -1,6 +1,6 @@
 from __future__ import annotations
-from typing import Iterable, Type, Optional, TYPE_CHECKING, overload
 import abc
+from typing import Annotated, Any, Iterable, Type, Optional, TYPE_CHECKING, get_type_hints, overload, get_origin, get_args
 from ormlambda.sql.types import TableType, ComparerType, ColumnType
 from ormlambda import ConditionType
 
@@ -8,6 +8,19 @@ if TYPE_CHECKING:
     import re
     from ormlambda import Table
     from ormlambda.sql.comparer import Comparer, Regex, Like
+    from ormlambda.sql.type_api import TypeEngine
+
+
+from ormlambda.types import (
+    # metadata
+    PrimaryKey,
+    AutoGenerated,
+    AutoIncrement,
+    Unique,
+    CheckTypes,
+    Default,
+    NotNull,
+)
 
 
 class Column[TProp]:
@@ -21,6 +34,9 @@ class Column[TProp]:
         "is_auto_generated",
         "is_auto_increment",
         "is_unique",
+        "is_not_null",
+        "default_value",
+        "sql_type",
         "__private_name",
         "_check",
     )
@@ -37,7 +53,9 @@ class Column[TProp]:
         is_auto_generated: bool = False,
         is_auto_increment: bool = False,
         is_unique: bool = False,
+        is_not_null: bool = False,
         check_types: bool = True,
+        default: Optional[Any] = None,
     ) -> None: ...
 
     def __init__[T: Table](
@@ -48,8 +66,10 @@ class Column[TProp]:
         is_auto_generated: bool = False,
         is_auto_increment: bool = False,
         is_unique: bool = False,
+        is_not_null: bool = False,
         check_types: bool = True,
         column_name: Optional[str] = None,
+        default: Optional[Any] = None,
     ) -> None:
         if dtype is None and column_name is None:
             raise AttributeError("You must specify either the 'dtype' or 'column_name' attribute.")
@@ -62,14 +82,17 @@ class Column[TProp]:
         self.column_name: Optional[str] = column_name
         self.__private_name: Optional[str] = None
         self._check = check_types
+        self.default_value: TProp = default
+        self.sql_type: TypeEngine[TProp] = None
 
         self.is_primary_key: bool = is_primary_key
         self.is_auto_generated: bool = is_auto_generated
         self.is_auto_increment: bool = is_auto_increment
         self.is_unique: bool = is_unique
+        self.is_not_null: bool = is_not_null
 
     def __repr__(self) -> str:
-        return f"{type(self).__name__}[{self.dtype.__name__}] => {self.column_name}"
+        return f"{type(self).__name__}[{self.dtype.__class__.__name__}] => {self.column_name}"
 
     def __str__(self) -> str:
         return self.table.__table_name__ + "." + self.column_name
@@ -79,6 +102,8 @@ class Column[TProp]:
         self.column_name = name
         self.__private_name = self.PRIVATE_CHAR + name
 
+        self._fill_from_annotations(owner, name)
+
     def __get__(self, obj, objtype=None) -> ColumnType[TProp]:
         if not obj:
             return self
@@ -100,43 +125,78 @@ class Column[TProp]:
                 self.is_auto_generated,
                 self.is_auto_increment,
                 self.is_unique,
+                self.is_not_null,
             )
         )
 
+    def _fill_from_annotations[T: Table](self, obj: Type[T], name: str) -> None:
+        """Read the metada when using Annotated typing class, and set the attributes accordingly"""
+
+        from ormlambda.sql.type_api import TypeEngine
+
+        annotations = get_type_hints(obj, include_extras=True)
+        if name in annotations:
+            annotation = annotations[name]
+            if get_origin(annotation) is Annotated:
+                dtype, *metadata = get_args(annotation)
+
+                if not self.dtype:
+                    self.dtype = dtype
+
+                for meta in metadata:
+                    if isinstance(meta, TypeEngine):
+                        self.sql_type = meta
+                    elif isinstance(meta, PrimaryKey):
+                        self.is_primary_key = True
+                    elif isinstance(meta, AutoGenerated):
+                        self.is_auto_generated = True
+                    elif isinstance(meta, AutoIncrement):
+                        self.is_auto_increment = True
+                    elif isinstance(meta, Unique):
+                        self.is_unique = True
+                    elif isinstance(meta, CheckTypes):
+                        self._check = True
+                    elif isinstance(meta, Default):
+                        self.default_value = meta.value
+                        self.is_auto_generated = True
+                    elif isinstance(meta, NotNull):
+                        self.is_not_null = True
+        return None
+
     @abc.abstractmethod
-    def __comparer_creator[LTable: Table, OTherTable: Table, OTherType](self, other: ColumnType[OTherType], compare: ComparerType, *args) -> Comparer:
+    def __comparer_creator(self, other: ColumnType, compare: ComparerType) -> Comparer:
         from ormlambda.sql.comparer import Comparer
 
-        return Comparer[LTable, TProp, OTherTable, OTherType](self, other, compare, *args)
+        return Comparer(self, other, compare)
 
-    def __eq__[LTable, OTherTable, OTherProp](self, other: ColumnType[OTherProp], *args) -> Comparer[LTable, TProp, OTherTable, OTherProp]:
-        return self.__comparer_creator(other, ConditionType.EQUAL.value, *args)
+    def __eq__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.EQUAL.value)
 
-    def __ne__[LTable, OTherTable, OtherProp](self, other: ColumnType[OtherProp], *args) -> Comparer[LTable, TProp, OTherTable, OtherProp]:
-        return self.__comparer_creator(other, ConditionType.NOT_EQUAL.value, *args)
+    def __ne__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.NOT_EQUAL.value)
 
-    def __lt__[LTable, OTherTable, OtherProp](self, other: ColumnType[OtherProp], *args) -> Comparer[LTable, TProp, OTherTable, OtherProp]:
-        return self.__comparer_creator(other, ConditionType.LESS_THAN.value, *args)
+    def __lt__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.LESS_THAN.value)
 
-    def __le__[LTable, OTherTable, OtherProp](self, other: ColumnType[OtherProp], *args) -> Comparer[LTable, TProp, OTherTable, OtherProp]:
-        return self.__comparer_creator(other, ConditionType.LESS_THAN_OR_EQUAL.value, *args)
+    def __le__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.LESS_THAN_OR_EQUAL.value)
 
-    def __gt__[LTable, OTherTable, OtherProp](self, other: ColumnType[OtherProp], *args) -> Comparer[LTable, TProp, OTherTable, OtherProp]:
-        return self.__comparer_creator(other, ConditionType.GREATER_THAN.value, *args)
+    def __gt__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.GREATER_THAN.value)
 
-    def __ge__[LTable, OTherTable, OtherProp](self, other: ColumnType[OtherProp], *args) -> Comparer[LTable, TProp, OTherTable, OtherProp]:
-        return self.__comparer_creator(other, ConditionType.GREATER_THAN_OR_EQUAL.value, *args)
+    def __ge__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.GREATER_THAN_OR_EQUAL.value)
 
-    def contains[LTable, OTherTable, OtherProp](self, other: ColumnType[OtherProp], *args) -> Comparer[LTable, TProp, OTherTable, OtherProp]:
+    def contains(self, other: ColumnType) -> Comparer:
         if not isinstance(other, tuple) and isinstance(other, Iterable):
             other = tuple(other)
 
-        return self.__comparer_creator(other, ConditionType.IN.value, *args)
+        return self.__comparer_creator(other, ConditionType.IN.value)
 
-    def not_contains[LTable, OTherTable, OtherProp](self, other: ColumnType[OtherProp], *args) -> Comparer[LTable, TProp, OTherTable, OtherProp]:
-        return self.__comparer_creator(other, ConditionType.NOT_IN.value, *args)
+    def not_contains(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.NOT_IN.value)
 
-    def regex[LProp, RProp](self, pattern: str, flags: Optional[re.RegexFlag | Iterable[re.RegexFlag]] = None) -> Regex[LProp, RProp]:
+    def regex(self, pattern: str, flags: Optional[re.RegexFlag | Iterable[re.RegexFlag]] = None) -> Regex:
         from ormlambda.sql.comparer import Regex
 
         if not isinstance(flags, Iterable):
@@ -148,7 +208,7 @@ class Column[TProp]:
             flags=flags,
         )
 
-    def like[LProp, RProp](self, pattern: str) -> Like[LProp, RProp]:
+    def like(self, pattern: str) -> Like:
         from ormlambda.sql.comparer import Like
 
         return Like(self, pattern)