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

ormlambda/sql/compiler.py

@@ -0,0 +1,427 @@
+from __future__ import annotations
+import abc
+from typing import Any, ClassVar, Optional, TYPE_CHECKING
+
+from ormlambda.sql.ddl import CreateColumn
+from ormlambda.sql.foreign_key import ForeignKey
+from ormlambda.sql.sqltypes import resolve_primitive_types
+
+from .visitors import Visitor
+from ormlambda import util
+from ormlambda.sql.type_api import TypeEngine
+
+if TYPE_CHECKING:
+    from ormlambda import Column
+    from .visitors import Element
+    from .elements import ClauseElement
+    from ormlambda.dialects import Dialect
+    from ormlambda.sql.ddl import CreateTable, CreateSchema, DropSchema
+    from .sqltypes import (
+        INTEGER,
+        SMALLINTEGER,
+        BIGINTEGER,
+        NUMERIC,
+        FLOAT,
+        REAL,
+        DOUBLE,
+        STRING,
+        TEXT,
+        UNICODE,
+        UNICODETEXT,
+        NCHAR,
+        VARCHAR,
+        NVARCHAR,
+        CHAR,
+        DATE,
+        TIME,
+        DATETIME,
+        TIMESTAMP,
+        BOOLEAN,
+        LARGEBINARY,
+        VARBINARY,
+        ENUM,
+        POINT,
+    )
+
+    from ormlambda.sql.clauses import (
+        Insert,
+        Delete,
+        Upsert,
+        Update,
+        Limit,
+        Offset,
+        Count,
+        Where,
+        Having,
+        Order,
+        Concat,
+        Max,
+        Min,
+        Sum,
+        Groupby,
+    )
+
+
+class Compiled:
+    """Represent a compiled SQL or DDL expression.
+
+    The ``__str__`` method of the ``Compiled`` object should produce
+    the actual text of the statement.  ``Compiled`` objects are
+    specific to their underlying database dialect, and also may
+    or may not be specific to the columns referenced within a
+    particular set of bind parameters.  In no case should the
+    ``Compiled`` object be dependent on the actual values of those
+    bind parameters, even though it may reference those values as
+    defaults.
+    """
+
+    dialect: Dialect
+    "The dialect to compile against."
+
+    statement: Optional[ClauseElement] = None
+    "The statement to compile."
+
+    string: str = ""
+    "The string representation of the ``statement``"
+
+    _gen_time: float
+    "The time when the statement was generated."
+
+    is_sql: ClassVar[bool] = False
+    is_ddl: ClassVar[bool] = False
+
+    def __init__(
+        self,
+        dialect: Dialect,
+        statement: Optional[ClauseElement] = None,
+        **kw: Any,
+    ) -> None:
+        """Construct a new :class:`.Compiled` object.
+
+        :param dialect: :class:`.Dialect` to compile against.
+
+        :param statement: :class:`_expression.ClauseElement` to be compiled.
+
+        """
+        self.dialect = dialect
+
+        if statement is not None:
+            self.statement = statement
+        self.string = self.process(self.statement, **kw)
+
+    @property
+    def sql_compiler(self):
+        """Return a Compiled that is capable of processing SQL expressions.
+
+        If this compiler is one, it would likely just return 'self'.
+
+        """
+
+        raise NotImplementedError()
+
+    def process(self, obj: Element, **kwargs: Any) -> str:
+        return obj._compiler_dispatch(self, **kwargs)
+
+
+class TypeCompiler(Visitor):
+    """Base class for all type compilers."""
+
+    def __init__(self, dialect: Dialect):
+        self.dialect = dialect
+
+    def process(self, type_: TypeEngine[Any], **kw: Any) -> str:
+        """Process a type object into a string representation.
+
+        :param type_: The type object to process.
+        :param kw: Additional keyword arguments.
+        :return: The string representation of the type object.
+        """
+        if not isinstance(type_, TypeEngine):
+            type_ = resolve_primitive_types(type_)
+        return type_._compiler_dispatch(self, **kw)
+
+
+class SQLCompiler(Compiled, abc.ABC):
+    is_sql = True
+
+    @abc.abstractmethod
+    def visit_insert(self, insert: Insert, **kw) -> Insert: ...
+    @abc.abstractmethod
+    def visit_delete(self, delete: Delete, **kw) -> Delete: ...
+    @abc.abstractmethod
+    def visit_upsert(self, upsert: Upsert, **kw) -> Upsert: ...
+    @abc.abstractmethod
+    def visit_update(self, update: Update, **kw) -> Update: ...
+    @abc.abstractmethod
+    def visit_limit(self, limit: Limit, **kw) -> Limit: ...
+    @abc.abstractmethod
+    def visit_offset(self, offset: Offset, **kw) -> Offset: ...
+    @abc.abstractmethod
+    def visit_count(self, count: Count, **kw) -> Count: ...
+    @abc.abstractmethod
+    def visit_where(self, where: Where, **kw) -> Where: ...
+    @abc.abstractmethod
+    def visit_having(self, having: Having, **kw) -> Having: ...
+    @abc.abstractmethod
+    def visit_order(self, order: Order, **kw) -> Order: ...
+    @abc.abstractmethod
+    def visit_concat(self, concat: Concat, **kw) -> Concat: ...
+    @abc.abstractmethod
+    def visit_max(self, max: Max, **kw) -> Max: ...
+    @abc.abstractmethod
+    def visit_min(self, min: Min, **kw) -> Min: ...
+    @abc.abstractmethod
+    def visit_sum(self, sum: Sum, **kw) -> Sum: ...
+    @abc.abstractmethod
+    def visit_group_by(self, groupby: Groupby, **kw) -> Groupby: ...
+
+
+class DDLCompiler(Compiled):
+    is_ddl = True
+
+    if TYPE_CHECKING:
+
+        def __init__(
+            self,
+            dialect: Dialect,
+            statement: Optional[ClauseElement] = None,
+            **kw: Any,
+        ) -> None: ...
+
+    @property
+    def sql_compiler(self):
+        """Return a SQL compiler that is capable of processing SQL expressions.
+
+        This method returns the SQL compiler for the dialect, which is
+        used to process SQL expressions.
+
+        """
+        return self.dialect.statement_compiler(self.dialect, None)
+
+    def visit_create_schema(self, create: CreateSchema, **kw) -> str:
+        """
+        Generate a CREATE SCHEMA SQL statement for MySQL.
+
+        Args:
+            schema_name (str): Name of the schema/database to create
+            if_not_exists (bool): Whether to include IF NOT EXISTS clause
+
+        Returns:
+            str: The SQL CREATE SCHEMA statement
+
+        Raises:
+            ValueError: If schema_name is empty or contains invalid characters
+        """
+        schema_name = create.schema
+
+        util.avoid_sql_injection(schema_name)
+
+        if_not_exists_clause = "IF NOT EXISTS " if create.if_not_exists else ""
+        return f"CREATE SCHEMA {if_not_exists_clause}{schema_name};"
+
+    def visit_drop_schema(self, drop: DropSchema, **kw):
+        if_exists_clause = "IF EXISTS " if drop.if_exists else ""
+        return f"DROP SCHEMA {if_exists_clause}{drop.schema};"
+
+    def visit_schema_exists(self, schema: str) -> bool:
+        return f"SHOW DATABASES LIKE {schema};"
+        # return f"SHOW DATABASES LIKE {self.dialect.caster.PLACEHOLDER};", (schema,)
+
+    def visit_create_table(self, create: CreateTable, **kw) -> str:
+        tablecls = create.element
+        column_sql: list[str] = []
+        for create_col in create.columns:
+            try:
+                processed = self.process(create_col)
+                if processed is not None:
+                    column_sql.append(processed)
+
+            except Exception:
+                raise
+
+        foreign_keys = ForeignKey.create_query(tablecls, self.dialect)
+        table_options = " ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci"
+
+        sql = f"CREATE TABLE {tablecls.__table_name__} (\n\t"
+        sql += ",\n\t".join(column_sql)
+        sql += "\n\t" if not foreign_keys else ",\n\t"
+        sql += ",\n\t".join(foreign_keys)
+        sql += f"\n){table_options};"
+        return sql
+
+    def visit_create_column(self, create: CreateColumn, first_pk=False, **kw):  # noqa: F821
+        column = create.element
+        return self.get_column_specification(column)
+
+    def get_column_specification(self, column: Column, **kwargs):
+        colspec = column.column_name + " " + self.dialect.type_compiler_instance.process(column.dtype)
+        default = self.get_column_default_string(column)
+        if default is not None:
+            colspec += " DEFAULT " + default
+
+        if column.is_not_null:
+            colspec += " NOT NULL"
+
+        if column.is_primary_key:
+            colspec += " PRIMARY KEY"
+        return colspec
+
+    def get_column_default_string(self, column: Column) -> Optional[str]:
+        if isinstance(column.default_value, str):
+            return column.default_value
+        if not column.default_value:
+            return None
+        return None
+
+
+class GenericTypeCompiler(TypeCompiler):
+    """Generic type compiler
+
+    This class is used to compile ormlambda types into their
+    string representations for the given dialect.
+    """
+
+    def _render_string_type(self, type_: STRING, name: str, length_override: Optional[int] = None):
+        text = name
+        if length_override:
+            text += "(%d)" % length_override
+        elif type_.length:
+            text += "(%d)" % type_.length
+        if type_.collation:
+            text += ' COLLATE "%s"' % type_.collation
+        return text
+
+    def visit_INTEGER(self, type_: INTEGER, **kw):
+        return "INTEGER"
+
+    def visit_SMALLINTEGER(self, type_: SMALLINTEGER, **kw):
+        return "SMALLINTEGER"
+
+    def visit_BIGINTEGER(self, type_: BIGINTEGER, **kw):
+        return "BIGINTEGER"
+
+    def visit_NUMERIC(self, type_: NUMERIC, **kw):
+        return "NUMERIC"
+
+    def visit_FLOAT(self, type_: FLOAT, **kw):
+        return "FLOAT"
+
+    def visit_REAL(self, type_: REAL, **kw):
+        return "REAL"
+
+    def visit_DOUBLE(self, type_: DOUBLE, **kw):
+        return "DOUBLE"
+
+    def visit_TEXT(self, type_: TEXT, **kw):
+        return self._render_string_type(type_, "TEXT", **kw)
+
+    def visit_UNICODE(self, type_: UNICODE, **kw):
+        return self._render_string_type(type_, "UNICODE", **kw)
+
+    def visit_UNICODETEXT(self, type_: UNICODETEXT, **kw):
+        return self._render_string_type(type_, "UNICODETEXT", **kw)
+
+    def visit_CHAR(self, type_: CHAR, **kw):
+        return self._render_string_type(type_, "CHAR", **kw)
+
+    def visit_NCHAR(self, type_: NCHAR, **kw):
+        return self._render_string_type(type_, "NCHAR", **kw)
+
+    def visit_VARCHAR(self, type_: VARCHAR, **kw):
+        return self._render_string_type(type_, "VARCHAR", **kw)
+
+    def visit_NVARCHAR(self, type_: NVARCHAR, **kw):
+        return self._render_string_type(type_, "NVARCHAR", **kw)
+
+    def visit_DATE(self, type_: DATE, **kw):
+        return "DATE"
+
+    def visit_TIME(self, type_: TIME, **kw):
+        return "TIME"
+
+    def visit_DATETIME(self, type_: DATETIME, **kw):
+        return "DATETIME"
+
+    def visit_TIMESTAMP(self, type_: TIMESTAMP, **kw):
+        return "TIMESTAMP"
+
+    def visit_BOOLEAN(self, type_: BOOLEAN, **kw):
+        return "BOOLEAN"
+
+    def visit_LARGEBINARY(self, type_: LARGEBINARY, **kw):
+        return "LARGEBINARY"
+
+    def visit_VARBINARY(self, type_: VARBINARY, **kw):
+        return "VARBINARY"
+
+    def visit_ENUM(self, type_: ENUM, **kw):
+        return "ENUM"
+
+    def visit_BLOB(self, type_: LARGEBINARY, **kw):
+        return "BLOB"
+
+    def visit_null(self, type_: POINT, **kw):
+        return "NULL"
+
+    def visit_POINT(self, _type: POINT, **kw):
+        return "POINT"
+
+    def visit_uuid(self, type_, **kw):
+        if not type_.native_uuid or not self.dialect.supports_native_uuid:
+            return self._render_string_type(type_, "CHAR", length_override=32)
+        else:
+            return self.visit_UUID(type_, **kw)
+
+    def visit_large_binary(self, type_, **kw):
+        return self.visit_BLOB(type_, **kw)
+
+    def visit_boolean(self, type_, **kw):
+        return self.visit_BOOLEAN(type_, **kw)
+
+    def visit_time(self, type_, **kw):
+        return self.visit_TIME(type_, **kw)
+
+    def visit_datetime(self, type_, **kw):
+        return self.visit_DATETIME(type_, **kw)
+
+    def visit_date(self, type_, **kw):
+        return self.visit_DATE(type_, **kw)
+
+    def visit_big_integer(self, type_, **kw):
+        return self.visit_BIGINT(type_, **kw)
+
+    def visit_small_integer(self, type_, **kw):
+        return self.visit_SMALLINT(type_, **kw)
+
+    def visit_integer(self, type_, **kw):
+        return self.visit_INTEGER(type_, **kw)
+
+    def visit_real(self, type_, **kw):
+        return self.visit_REAL(type_, **kw)
+
+    def visit_float(self, type_, **kw):
+        return self.visit_FLOAT(type_, **kw)
+
+    def visit_double(self, type_, **kw):
+        return self.visit_DOUBLE(type_, **kw)
+
+    def visit_numeric(self, type_, **kw):
+        return self.visit_NUMERIC(type_, **kw)
+
+    def visit_string(self, type_, **kw):
+        return self.visit_VARCHAR(type_, **kw)
+
+    def visit_unicode(self, type_, **kw):
+        return self.visit_VARCHAR(type_, **kw)
+
+    def visit_text(self, type_, **kw):
+        return self.visit_TEXT(type_, **kw)
+
+    def visit_unicode_text(self, type_, **kw):
+        return self.visit_TEXT(type_, **kw)
+
+    def visit_enum(self, type_, **kw):
+        return self.visit_VARCHAR(type_, **kw)
+
+    def visit_point(self, type_: POINT, **kw):
+        return self.visit_POINT(type_, **kw)

ormlambda/sql/ddl.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from .elements import ClauseElement
+
+if TYPE_CHECKING:
+    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 CreateTable(BaseDDLElement):
+    """
+    Class representing a CREATE TABLE statement.
+    """
+
+    __visit_name__ = "create_table"
+
+    def __init__(self, element: Table):
+        self.element = element
+        self.columns = [CreateColumn(c) for c in element.get_columns()]
+
+
+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

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,51 @@ 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"
+
+    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 +116,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 +147,5 @@ class ForeignKey[TLeft: Table, TRight: Table](IQuery):
         right = self._tright
         comparer = self._relationship(left, right)
         comparer.set_context(context)
+        comparer._dialect = dialect
         return comparer