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

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,40 +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__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.EQUAL.value)
 
-    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 __ne__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.NOT_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 __lt__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.LESS_THAN.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 __le__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.LESS_THAN_OR_EQUAL.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 __gt__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.GREATER_THAN.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 __ge__(self, other: ColumnType) -> Comparer:
+        return self.__comparer_creator(other, ConditionType.GREATER_THAN_OR_EQUAL.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 contains(self, other: ColumnType) -> Comparer:
+        if not isinstance(other, tuple) and isinstance(other, Iterable):
+            other = tuple(other)
 
-    def contains[LTable, OTherTable, OtherProp](self, other: ColumnType[OtherProp], *args) -> Comparer[LTable, TProp, OTherTable, OtherProp]:
-        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):
@@ -145,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)

ormlambda/sql/comparer.py

@@ -8,10 +8,11 @@ from ormlambda.common.interfaces.IQueryCommand import IQuery
 from ormlambda.sql.types import ConditionType, ComparerTypes
 from ormlambda.sql.clause_info import ClauseInfo
 from ormlambda import ConditionType as ConditionEnum
+from ormlambda.sql.elements import Element
 
 if tp.TYPE_CHECKING:
     from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
-    from ormlambda.sql import Table
+    from ormlambda.dialects import Dialect
 
 
 class ICleaner(abc.ABC):
@@ -45,75 +46,88 @@ class CleanValue:
         return temp_name
 
 
-class Comparer[LTable: Table, LProp, RTable: Table, RProp](IQuery):
+class Comparer(Element, IQuery):
+    __visit_name__ = "comparer"
+
     def __init__(
         self,
-        left_condition: ConditionType[LProp],
-        right_condition: ConditionType[RProp],
+        left_condition: ConditionType,
+        right_condition: ConditionType,
         compare: ComparerTypes,
         context: ClauseContextType = None,
         flags: tp.Optional[tp.Iterable[re.RegexFlag]] = None,
+        dialect: tp.Optional[Dialect] = None,
     ) -> None:
         self._context: ClauseContextType = context
         self._compare: ComparerTypes = compare
-        self._left_condition: Comparer[LTable, LProp, RTable, RProp] | ClauseInfo[LTable] = left_condition
-        self._right_condition: Comparer[LTable, LProp, RTable, RProp] | ClauseInfo[RTable] = right_condition
+        self._left_condition: Comparer | ClauseInfo = left_condition
+        self._right_condition: Comparer | ClauseInfo = right_condition
         self._flags = flags
+        self._dialect = dialect
 
     def set_context(self, context: ClauseContextType) -> None:
         self._context = context
+        return None
+
+    def set_dialect(self, dialect: Dialect) -> None:
+        self._dialect = dialect
+        return None
 
     def __repr__(self) -> str:
         return f"{Comparer.__name__}: {self.query}"
 
-    def _create_clause_info[TTable](self, cond: ConditionType[LProp]) -> Comparer[LTable, LProp, RTable, RProp] | ClauseInfo[TTable]:
+    def _create_clause_info(self, cond: ConditionType, dialect: Dialect, **kw) -> Comparer | ClauseInfo:
         from ormlambda import Column
 
         if isinstance(cond, Comparer):
             return cond
-        if isinstance(cond, Column):
-            return ClauseInfo(cond.table, cond, alias_clause=None, context=self._context)
+        table = None if not isinstance(cond, Column) else cond.table
+
         # it a value that's not depend of any Table
-        return ClauseInfo(None, cond, alias_clause=None, context=self._context)
+        return ClauseInfo(
+            table,
+            cond,
+            alias_clause=None,
+            context=self._context,
+            dialect=dialect,
+            **kw,
+        )
 
-    @property
-    def left_condition(self) -> Comparer | ClauseInfo[LTable]:
-        return self._create_clause_info(self._left_condition)
+    def left_condition(self, dialect: Dialect) -> Comparer | ClauseInfo:
+        return self._create_clause_info(self._left_condition, dialect=dialect)
 
-    @property
-    def right_condition(self) -> Comparer | ClauseInfo[RTable]:
-        return self._create_clause_info(self._right_condition)
+    def right_condition(self, dialect: Dialect) -> Comparer | ClauseInfo:
+        return self._create_clause_info(self._right_condition, dialect=dialect)
 
     @property
     def compare(self) -> ComparerTypes:
         return self._compare
 
-    @property
-    def query(self) -> str:
-        lcond = self.left_condition.query
-        rcond = self.right_condition.query
+    def query(self, dialect: Dialect, **kwargs) -> str:
+        lcond = self.left_condition(dialect).query(dialect, **kwargs)
+        rcond = self.right_condition(dialect).query(dialect, **kwargs)
 
         if self._flags:
             rcond = CleanValue(rcond, self._flags).clean()
 
         return f"{lcond} {self._compare} {rcond}"
 
-    def __and__(self, other: Comparer, context: ClauseContextType = None) -> Comparer:
+    def __and__(self, other: Comparer, **kwargs) -> Comparer:
         # Customize the behavior of '&'
-        return Comparer(self, other, "AND", context=context)
+        return Comparer(self, other, "AND", **kwargs)
 
-    def __or__(self, other: Comparer, context: ClauseContextType = None) -> Comparer:
+    def __or__(self, other: Comparer, **kwargs) -> Comparer:
         # Customize the behavior of '|'
-        return Comparer(self, other, "OR", context=context)
+        return Comparer(self, other, "OR", **kwargs)
 
     @classmethod
-    def join_comparers(cls, comparers: list[Comparer], restrictive: bool = True, context: ClauseContextType = None) -> str:
+    def join_comparers(cls, comparers: list[Comparer], restrictive: bool = True, context: ClauseContextType = None, *, dialect) -> str:
         if not isinstance(comparers, tp.Iterable):
             raise ValueError(f"Excepted '{Comparer.__name__}' iterable not {type(comparers).__name__}")
         if len(comparers) == 1:
             comparer = comparers[0]
-            comparer.set_context(context)
-            return comparer.query
+            comparer._context = context
+            return comparer.query(dialect)
 
         join_method = cls.__or__ if not restrictive else cls.__and__
 
@@ -121,19 +135,19 @@ class Comparer[LTable: Table, LProp, RTable: Table, RProp](IQuery):
         for i in range(len(comparers) - 1):
             if ini_comparer is None:
                 ini_comparer = comparers[i]
-                ini_comparer.set_context(context)
+                ini_comparer._context = context
             right_comparer = comparers[i + 1]
-            right_comparer.set_context(context)
-            new_comparer = join_method(ini_comparer, right_comparer, context=context)
+            right_comparer._context = context
+            new_comparer = join_method(ini_comparer, right_comparer, context=context, dialect=dialect)
             ini_comparer = new_comparer
-        return new_comparer.query
+        return new_comparer.query(dialect)
 
 
-class Regex[LProp, RProp](Comparer[None, LProp, None, RProp]):
+class Regex(Comparer):
     def __init__(
         self,
-        left_condition: ConditionType[LProp],
-        right_condition: ConditionType[RProp],
+        left_condition: ConditionType,
+        right_condition: ConditionType,
         context: ClauseContextType = None,
         flags: tp.Optional[tp.Iterable[re.RegexFlag]] = None,
     ):
@@ -146,11 +160,11 @@ class Regex[LProp, RProp](Comparer[None, LProp, None, RProp]):
         )
 
 
-class Like[LProp, RProp](Comparer[None, LProp, None, RProp]):
+class Like(Comparer):
     def __init__(
         self,
-        left_condition: ConditionType[LProp],
-        right_condition: ConditionType[RProp],
+        left_condition: ConditionType,
+        right_condition: ConditionType,
         context: ClauseContextType = None,
     ):
         super().__init__(left_condition, right_condition, ConditionEnum.LIKE.value, context)