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

ormlambda/sql/ddl.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from .elements import ClauseElement
+
+if TYPE_CHECKING:
+    from ormlambda import URL
+    from ormlambda.dialects.interface.dialect import Dialect
+    from ormlambda import Column
+    from ormlambda import Table
+
+
+class BaseDDLElement(ClauseElement):
+    """
+    Base class for all DDL elements.
+    """
+
+    __visit_name__ = "ddl_element"
+
+    def _compiler(self, dialect: Dialect, **kw) -> str:
+        """
+        Compile the DDL element into a SQL string.
+        """
+        return dialect.ddl_compiler(dialect, self, **kw)
+
+
+class CreateDropTable:
+    def __init__(self, element: Table):
+        self.element = element
+        self.columns = [CreateColumn(c) for c in element.get_columns()]
+
+
+class CreateTable(CreateDropTable, BaseDDLElement):
+    """
+    Class representing a CREATE TABLE statement.
+    """
+
+    __visit_name__ = "create_table"
+
+
+class DropTable(CreateDropTable, BaseDDLElement):
+    __visit_name__ = "drop_table"
+
+
+class CreateColumn[T](BaseDDLElement):
+    """
+    Class representing a column in a CREATE TABLE statement.
+    """
+
+    __visit_name__ = "create_column"
+
+    def __init__(self, element: Column[T]):
+        self.element = element
+
+
+class CreateSchema(BaseDDLElement):
+    __visit_name__ = "create_schema"
+
+    def __init__(self, schema: str, if_not_exists: bool = True):
+        self.schema: str = schema
+        self.if_not_exists: bool = if_not_exists
+
+
+class DropSchema(BaseDDLElement):
+    __visit_name__ = "drop_schema"
+
+    def __init__(self, schema: str, if_exists: bool = True):
+        self.schema = schema
+        self.if_exists = if_exists
+
+
+class SchemaExists(BaseDDLElement):
+    __visit_name__ = "schema_exists"
+
+    def __init__(self, schema: str):
+        self.schema = schema
+
+
+class CreateBackup(BaseDDLElement):
+    __visit_name__ = "create_backup"
+
+    def __init__(self, url: URL):
+        self.url = url

ormlambda/sql/elements.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+from typing import Optional, Any, TYPE_CHECKING
+
+from .visitors import Element
+
+if TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+    from .compiler import Compiled
+
+
+class CompilerElement(Element):
+    """
+    Base class for all compiler elements
+    """
+
+    __slots__ = ()
+    __visit_name__ = "compiler_element"
+
+    def compile(self, dialect: Optional[Dialect] = None, **kw: Any) -> Compiled:
+        if dialect is None:
+            raise TypeError("Either bind or dialect must be provided.")
+        return self._compiler(dialect, **kw)
+
+    def _compiler(self, dialect: Dialect, **kw: Any) -> Compiled:
+        """
+        Compile the element into a SQL string.
+        """
+        return dialect.statement_compiler(dialect, self, **kw)
+
+
+class ClauseElement(CompilerElement):
+    """
+    Base class for all clause elements.
+    """
+
+    __visit_name__ = "clause_element"

ormlambda/sql/foreign_key.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
-from typing import Callable, TYPE_CHECKING, Optional, Any, Type, cast, overload
+from typing import Callable, TYPE_CHECKING, Optional, Any, Type, cast, overload, ClassVar
 
 from ormlambda.common.interfaces.IQueryCommand import IQuery
-
+from ormlambda.sql.elements import Element
 
 if TYPE_CHECKING:
     from ormlambda.sql.comparer import Comparer
     from ormlambda import Table
     from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+    from ormlambda.dialects import Dialect
 
 
 class ForeignKeyContext(set["ForeignKey"]):
@@ -32,49 +33,59 @@ class ForeignKeyContext(set["ForeignKey"]):
         return super().add(element)
 
 
-class ForeignKey[TLeft: Table, TRight: Table](IQuery):
-    stored_calls: ForeignKeyContext = ForeignKeyContext()
+class ForeignKey[TLeft: Table, TRight: Table](Element, IQuery):
+    __visit_name__ = "foreign_key"
+
+    __slots__ = (
+        "_tright",
+        "_relationship",
+        "_comparer",
+        "_clause_name",
+        "_keep_alive",
+    )
+
+    stored_calls: ClassVar[ForeignKeyContext] = ForeignKeyContext()
 
     @overload
-    def __new__[LProp, RProp](self, comparer: Comparer[LProp, RProp], clause_name: str) -> None: ...
+    def __new__(self, comparer: Comparer, clause_name: str) -> None: ...
     @overload
-    def __new__[LProp, TRight, RProp](cls, tright: Type[TRight], relationship: Callable[[TLeft, TRight], Any | Comparer[TLeft, LProp, TRight, RProp]], keep_alive: bool = ...) -> TRight: ...
-
-    def __new__[LProp, TRight, RProp](
+    def __new__[TRight](
         cls,
-        tright: Optional[TRight] = None,
-        relationship: Optional[Callable[[TLeft, TRight], Any | Comparer[TLeft, LProp, TRight, RProp]]] = None,
-        *,
-        comparer: Optional[Comparer] = None,
-        clause_name: Optional[str] = None,
-        keep_alive: bool = False,
-    ) -> TRight:
+        tright: Type[TRight],
+        relationship: Callable[[TLeft, TRight], Any | Comparer],
+        keep_alive: bool = ...,
+        dialect: Dialect = ...,
+    ) -> TRight: ...
+
+    def __new__[TRight](cls, *args, **kwargs) -> TRight:
         return super().__new__(cls)
 
-    def __init__[LProp, RProp](
+    def __init__(
         self,
         tright: Optional[TRight] = None,
-        relationship: Optional[Callable[[TLeft, TRight], Any | Comparer[TLeft, LProp, TRight, RProp]]] = None,
+        relationship: Optional[Callable[[TLeft, TRight], Any | Comparer]] = None,
         *,
         comparer: Optional[Comparer] = None,
         clause_name: Optional[str] = None,
         keep_alive: bool = False,
+        **kwargs: Any,
     ) -> None:
+        self.kwargs = kwargs
         self._keep_alive = keep_alive
         if comparer is not None and clause_name is not None:
-            self.__init__with_comparer(comparer, clause_name)
+            self.__init__with_comparer(comparer, clause_name, **kwargs)
         else:
             self.__init_with_callable(tright, relationship)
 
-    def __init__with_comparer[LProp, RProp](self, comparer: Comparer[LProp, RProp], clause_name: str) -> None:
+    def __init__with_comparer(self, comparer: Comparer, clause_name: str, **kwargs) -> None:
         self._relationship = None
-        self._tleft: TLeft = comparer.left_condition.table
-        self._tright: TRight = comparer.right_condition.table
+        self._tleft: TLeft = comparer.left_condition(**kwargs).table
+        self._tright: TRight = comparer.right_condition(**kwargs).table
         self._clause_name: str = clause_name
-        self._comparer: Comparer[LProp, RProp] = comparer
+        self._comparer: Comparer = comparer
 
-    def __init_with_callable[LProp, RProp](self, tright: Optional[TRight], relationship: Optional[Callable[[TLeft, TRight], Comparer[LProp, RProp]]]) -> None:
-        self._relationship: Callable[[TLeft, TRight], Comparer[LProp, RProp]] = relationship
+    def __init_with_callable(self, tright: Optional[TRight], relationship: Optional[Callable[[TLeft, TRight], Comparer]]) -> None:
+        self._relationship: Callable[[TLeft, TRight], Comparer] = relationship
         self._tleft: TLeft = None
         self._tright: TRight = tright
         self._clause_name: str = None
@@ -113,29 +124,29 @@ class ForeignKey[TLeft: Table, TRight: Table](IQuery):
     def clause_name(self) -> str:
         return self._clause_name
 
-    @property
-    def query(self) -> str:
-        compare = self.resolved_function()
-        rcon = alias if (alias := compare.right_condition.alias_table) else compare.right_condition.table.__table_name__
-        return f"FOREIGN KEY ({self._tleft.__table_name__}) REFERENCES {rcon}({compare.right_condition._column.column_name})"
-
-    @property
-    def alias(self) -> str:
-        self._comparer = self.resolved_function()
-        lcol = self._comparer.left_condition._column.column_name
-        rcol = self._comparer.right_condition._column.column_name
+    def query(self, dialect: Dialect, **kwargs) -> str:
+        compare = self.resolved_function(dialect)
+        left_col = compare.left_condition(dialect).column
+        rcon = alias if (alias := compare.right_condition(dialect).alias_table) else compare.right_condition(dialect).table.__table_name__
+        return f"FOREIGN KEY ({left_col}) REFERENCES {rcon}({compare.right_condition(dialect).column})"
+
+    def get_alias(self, dialect: Dialect) -> str:
+        self._comparer = self.resolved_function(dialect)
+        self._comparer._dialect = dialect
+        lcol = self._comparer.left_condition(dialect)._column.column_name
+        rcol = self._comparer.right_condition(dialect)._column.column_name
         return f"{self.tleft.__table_name__}_{lcol}_{rcol}"
 
     @classmethod
-    def create_query(cls, orig_table: Table) -> list[str]:
+    def create_query(cls, orig_table: Table, dialect: Dialect) -> list[str]:
         clauses: list[str] = []
 
-        for attr in vars(orig_table):
+        for attr in orig_table.__dict__.values():
             if isinstance(attr, ForeignKey):
-                clauses.append(attr.query)
+                clauses.append(attr.query(dialect))
         return clauses
 
-    def resolved_function[LProp: Any, RProp: Any](self, context: ClauseContextType = None) -> Comparer[LProp, RProp]:
+    def resolved_function[LProp: Any, RProp: Any](self, dialect: Dialect, context: Optional[ClauseContextType] = None) -> Comparer:
         """ """
         if self._comparer is not None:
             return self._comparer
@@ -144,4 +155,15 @@ class ForeignKey[TLeft: Table, TRight: Table](IQuery):
         right = self._tright
         comparer = self._relationship(left, right)
         comparer.set_context(context)
+        comparer._dialect = dialect
         return comparer
+
+    def __hash__(self):
+        return hash((
+            self._tleft,
+            self._tright,
+            self._clause_name,
+        ))
+
+    def __eq__(self, other: ForeignKey):
+        return hash(other) == hash(self)

ormlambda/{databases/my_sql → sql}/functions/concat.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import typing as tp
 
 from ormlambda.sql.clause_info import AggregateFunctionBase
@@ -9,7 +10,11 @@ from ormlambda.sql.clause_info import ClauseInfo
 type ConcatResponse[TProp] = tuple[str | ColumnType[TProp]]
 
 
-class Concat[T](AggregateFunctionBase):
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
+
+class Concat[T](AggregateFunctionBase[T]):
     @staticmethod
     def FUNCTION_NAME() -> str:
         return "CONCAT"
@@ -19,22 +24,25 @@ class Concat[T](AggregateFunctionBase):
         values: ConcatResponse[TProp],
         alias_clause: AliasType[ColumnType[TProp]] = "concat",
         context: ClauseContextType = None,
+        *,
+        dialect: Dialect,
     ) -> None:
         super().__init__(
             table=None,
             column=values,
             alias_clause=alias_clause,
             context=context,
+            dtype=str,
+            dialect=dialect,
         )
 
     @tp.override
-    @property
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         columns: list[str] = []
 
         context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
 
-        for clause in self._convert_into_clauseInfo(self.unresolved_column, context=context):
+        for clause in self._convert_into_clauseInfo(self.unresolved_column, context=context, dialect=self._dialect):
             clause.alias_clause = self.alias_clause
             columns.append(clause)
-        return self._concat_alias_and_column(f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns)})", self._alias_aggregate)
+        return self._concat_alias_and_column(f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns,dialect=self._dialect)})", self._alias_aggregate)

ormlambda/{databases/my_sql → sql}/functions/max.py

@@ -6,6 +6,9 @@ from ormlambda.sql.clause_info import ClauseInfo
 from ormlambda.sql.types import ColumnType, AliasType
 from ormlambda.sql.clause_info import AggregateFunctionBase
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
 
 class Max(AggregateFunctionBase[None]):
     @staticmethod
@@ -17,6 +20,8 @@ class Max(AggregateFunctionBase[None]):
         elements: ColumnType[TProp],
         alias_clause: AliasType[ColumnType[TProp]] = "max",
         context: ClauseContextType = None,
+        *,
+        dialect: Dialect,
     ):
         super().__init__(
             table=None,
@@ -26,18 +31,18 @@ class Max(AggregateFunctionBase[None]):
             context=context,
             keep_asterisk=False,
             preserve_context=False,
+            dialect=dialect,
         )
 
     @tp.override
-    @property
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         columns: list[str] = []
 
         context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
-        for clause in self._convert_into_clauseInfo(self.unresolved_column, context):
+        for clause in self._convert_into_clauseInfo(self.unresolved_column, context, dialect=self._dialect):
             new_clause = clause
             new_clause.alias_clause = None
             columns.append(new_clause)
 
-        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns)})"
+        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns,dialect=self._dialect)})"
         return self._concat_alias_and_column(method_string, self._alias_aggregate)

ormlambda/{databases/my_sql → sql}/functions/min.py

@@ -6,6 +6,9 @@ from ormlambda.sql.clause_info import ClauseInfo
 from ormlambda.sql.types import ColumnType, AliasType
 from ormlambda.sql.clause_info import AggregateFunctionBase
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
 
 class Min(AggregateFunctionBase):
     @staticmethod
@@ -17,27 +20,20 @@ class Min(AggregateFunctionBase):
         elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
         alias_clause: AliasType[ColumnType[TProp]] = "min",
         context: ClauseContextType = None,
+        *,
+        dialect: Dialect,
     ):
-        super().__init__(
-            table=None,
-            column=elements,
-            alias_table=None,
-            alias_clause=alias_clause,
-            context=context,
-            keep_asterisk=False,
-            preserve_context=False,
-        )
+        super().__init__(table=None, column=elements, alias_table=None, alias_clause=alias_clause, context=context, keep_asterisk=False, preserve_context=False, dialect=dialect)
 
     @tp.override
-    @property
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         columns: list[str] = []
 
         context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
-        for clause in self._convert_into_clauseInfo(self.unresolved_column, context):
+        for clause in self._convert_into_clauseInfo(self.unresolved_column, context, dialect=self._dialect):
             new_clause = clause
             new_clause.alias_clause = None
             columns.append(new_clause)
 
-        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns)})"
+        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns,dialect=self._dialect)})"
         return self._concat_alias_and_column(method_string, self._alias_aggregate)

ormlambda/{databases/my_sql → sql}/functions/sum.py

@@ -6,18 +6,16 @@ from ormlambda.sql.clause_info import ClauseInfo
 from ormlambda.sql.types import ColumnType, AliasType
 from ormlambda.sql.clause_info import AggregateFunctionBase
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
 
 class Sum(AggregateFunctionBase):
     @staticmethod
     def FUNCTION_NAME() -> str:
         return "SUM"
 
-    def __init__[TProp](
-        self,
-        elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
-        alias_clause: AliasType[ColumnType[TProp]] = "sum",
-        context: ClauseContextType = None,
-    ):
+    def __init__[TProp](self, elements: tuple[ColumnType[TProp], ...] | ColumnType[TProp], alias_clause: AliasType[ColumnType[TProp]] = "sum", context: ClauseContextType = None, *, dialect: Dialect):
         super().__init__(
             table=None,
             column=elements,
@@ -26,18 +24,18 @@ class Sum(AggregateFunctionBase):
             context=context,
             keep_asterisk=False,
             preserve_context=False,
+            dialect=dialect,
         )
 
     @tp.override
-    @property
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         columns: list[str] = []
 
         context = ClauseInfoContext(table_context=self._context._table_context, clause_context=None) if self._context else None
-        for clause in self._convert_into_clauseInfo(self.unresolved_column, context):
+        for clause in self._convert_into_clauseInfo(self.unresolved_column, context, self._dialect):
             new_clause = clause
             new_clause.alias_clause = None
             columns.append(new_clause)
 
-        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns)})"
+        method_string = f"{self.FUNCTION_NAME()}({ClauseInfo.join_clauses(columns,dialect=self._dialect)})"
         return self._concat_alias_and_column(method_string, self._alias_aggregate)