ormlambda 3.35.2__py3-none-any.whl → 4.0.0__py3-none-any.whl

ormlambda/dialects/mysql/base.py

@@ -1,12 +1,22 @@
 from __future__ import annotations
 from types import ModuleType
+from ormlambda import ColumnProxy, ForeignKey, TableProxy
 from ormlambda.sql import compiler
+from ormlambda.sql.clause_info import ClauseInfo
+from ormlambda.common.errors import NotKeysInIAggregateError
+from ormlambda.sql.types import ASTERISK
+
+
 from .. import default
 from typing import TYPE_CHECKING, Any, Iterable
 
 if TYPE_CHECKING:
+    from test.test_clause_info import ST_Contains
+    from ormlambda import JoinSelector
+    from ormlambda.sql.comparer import Comparer
     from ormlambda.sql.column.column import Column
     from mysql import connector
+    from ormlambda.dialects.mysql.clauses import ST_AsText
 
 from .types import (
     _NumericType,
@@ -46,11 +56,9 @@ from ormlambda.sql.sqltypes import (
     DATE,
     UUID,
     VARBINARY,
-    BINARY,
 )
-
-
-from ormlambda.databases.my_sql import MySQLRepository, MySQLCaster
+from .caster import MySQLCaster
+from .repository import MySQLRepository
 
 
 if TYPE_CHECKING:
@@ -77,59 +85,231 @@ if TYPE_CHECKING:
     )
 
 
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext
-
-
 class MySQLCompiler(compiler.SQLCompiler):
     render_table_with_column_in_update_from = True
     """Overridden from base SQLCompiler value"""
 
-    def visit_select(self, select: Select, **kw):
-        return f"{select.CLAUSE} {select.COLUMNS} FROM {select.FROM.query(self.dialect, **kw)}"
-
-    def visit_group_by(self, groupby: GroupBy, **kw):
-        column = groupby._create_query(self.dialect, **kw)
-        return f"{groupby.FUNCTION_NAME()} {column}"
+    def visit_table_proxy(self, table: TableProxy, **kw) -> str:
+        param = {
+            "table": None,
+            "column": table._table_class.__table_name__,
+            "dialect": self.dialect,
+            "alias_clause": alias if (alias := table.get_table_chain()) else None,
+            **kw,
+        }
+        return ClauseInfo(**param).query(dialect=self.dialect)
+
+    def visit_column(self, column: Column, **kw) -> str:
+        params = {
+            "table": column.table,
+            "column": column.column_name,
+            "dtype": column.dtype,
+            "dialect": self.dialect,
+            **kw,
+        }
+        return ClauseInfo(**params).query(self.dialect)
+
+    def visit_column_proxy(self, column: ColumnProxy, **kw) -> str:
+        from ormlambda.sql.clause_info import ClauseInfo
+
+        alias_table = column.get_table_chain()
+
+        params = {
+            "table": column.table,
+            "column": column,
+            "alias_table": alias_table if alias_table else "{table}",
+            "alias_clause": column.alias or "{column}",
+            "dtype": column._column.dtype,
+            "dialect": self.dialect,
+            **kw,
+        }
+        clause_info = ClauseInfo(**params)
+        if column.alias != clause_info.alias_clause:
+            # FIXME [ ]: i don't understand why
+            column.alias = clause_info.alias_clause
+        return clause_info.query(self.dialect)
+
+    def visit_comparer(self, comparer: Comparer, **kwargs) -> str:
+        from ormlambda.sql.comparer import CleanValue, Comparer
+
+        def compile_condition(condition: Any):
+            if isinstance(condition, ColumnProxy | Comparer):
+                param = {
+                    "alias_clause": None,
+                    **kwargs,
+                }
+                return condition.compile(self.dialect, **param).string
+            return MySQLCaster.cast(condition, type(condition)).string_data
+
+        lcond = compile_condition(comparer.left_condition)
+        rcond = compile_condition(comparer.right_condition)
+
+        if comparer._flags:
+            rcond = CleanValue(rcond, comparer._flags).clean()
+
+        return f"{lcond} {comparer.compare} {rcond}"
+
+    def visit_join(self, join: JoinSelector) -> str:
+        rt = join.rcon.table
+        rtable = TableProxy(table_class=rt, path=join.rcon.path)
+
+        from_clause = rtable.compile(self.dialect, alias_clause=join.alias).string
+        left_table_clause = join.lcon.compile(self.dialect, alias_clause=None).string
+        right_table_clause = join.rcon.compile(self.dialect, alias_table=join.alias, alias_clause=None).string
+        list_ = [
+            join._by.value,  # inner join
+            from_clause,
+            "ON",
+            left_table_clause,
+            join._compareop,  # =
+            right_table_clause,
+        ]
+        return " ".join([x for x in list_ if x is not None])
+
+    def visit_select(self, select: Select):
+        params = {}
+
+        # COMMENT: when passing alias into 'select' method, we gonna replace the current aliases of columns with the generic one.
+        # TODOM []: Check if we manage some conditions or not
+        if select.avoid_duplicates:
+            params["alias_clause"] = lambda x: x.get_full_chain("_")
+        elif select.alias:
+            params["alias_clause"] = select.alias
+
+        columns = ClauseInfo.join_clauses(select.columns, ",", dialect=self.dialect, **params)
+        from_ = ClauseInfo(
+            select._table,
+            None,
+            alias_table=select._alias_table,
+            dialect=self.dialect,
+        ).query(self.dialect)
+
+        return f"SELECT {columns} FROM {from_}"
+
+    def visit_group_by(self, groupby: GroupBy):
+        column = ", ".join(x.compile(self.dialect, alias_clause=None).string for x in groupby.column)
+        return f"GROUP BY {column}"
 
     def visit_limit(self, limit: Limit, **kw):
-        return f"{limit.LIMIT} {limit._number}"
+        return f"LIMIT {limit._number}"
 
     # TODOH []: include the rest of visit methods
-    def visit_insert(self, insert: Insert, **kw) -> Insert: ...
-    def visit_delete(self, delete: Delete, **kw) -> Delete: ...
-    def visit_upsert(self, upsert: Upsert, **kw) -> Upsert: ...
-    def visit_update(self, update: Update, **kw) -> Update: ...
-    def visit_offset(self, offset: Offset, **kw) -> Offset:
-        return f"{offset.OFFSET} {offset._number}"
-
-    def visit_count(self, count: Count, **kw) -> Count: ...
-    def visit_where(self, where: Where, **kw) -> Where: ...
-    def visit_having(self, having: Having, **kw) -> Having: ...
-    def visit_order(self, order: Order, **kw) -> Order:
+    def visit_insert(self, insert: Insert, **kw) -> str:
+        pass
+
+    def visit_delete(self, delete: Delete, **kw) -> str:
+        pass
+
+    def visit_upsert(self, upsert: Upsert, **kw) -> str:
+        pass
+
+    def visit_update(self, update: Update, **kw) -> str:
+        pass
+
+    def visit_offset(self, offset: Offset, **kw) -> str:
+        return f"OFFSET {offset._number}"
+
+    def visit_count(self, count: Count, **kw) -> str:
+        if isinstance(count.column, ColumnProxy):
+            column = count.column.compile(self.dialect, alias_clause=None).string
+
+        elif isinstance(count.column, TableProxy):
+            column = ASTERISK
+
+        else:
+            column = count.column
+
+        return ClauseInfo.concat_alias_and_column(f"COUNT({column})", count.alias)
+
+    def visit_where(self, where: Where) -> str:
+        from ormlambda.sql.comparer import Comparer
+
+        if not where.comparer:
+            return ""
+        cols = Comparer.join_comparers(list(where.comparer), restrictive=where.restrictive, dialect=self.dialect)
+        return f"WHERE {cols}"
+
+    def visit_having(self, having: Having) -> str:
+        from ormlambda.sql.comparer import Comparer
+
+        cols = Comparer.join_comparers(list(having.comparer), restrictive=having.restrictive, dialect=self.dialect, table=None, literal=True)
+        return f"HAVING {cols}"
+
+    def visit_order(self, order: Order, **kw) -> str:
+        ORDER = "ORDER BY"
         string_columns: list[str] = []
-        columns = order.unresolved_column
+        columns = order.columns
 
         # 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(order._order_type[0])}"
-            return f"{order.FUNCTION_NAME()} {string_columns}"
 
         if not isinstance(columns, Iterable):
             columns = (columns,)
 
         assert len(columns) == len(order._order_type)
 
-        context = ClauseInfoContext(table_context=order._context._table_context, clause_context=None) if order._context else None
-        for index, clause in enumerate(order._convert_into_clauseInfo(columns, context, dialect=self.dialect)):
-            clause.alias_clause = None
-            string_columns.append(f"{clause.query(self.dialect, **kw)} {str(order._order_type[index])}")
-
-        return f"{order.FUNCTION_NAME()} {', '.join(string_columns)}"
-
-    def visit_concat(self, concat: Concat, **kw) -> Concat: ...
-    def visit_max(self, max: Max, **kw) -> Max: ...
-    def visit_min(self, min: Min, **kw) -> Min: ...
-    def visit_sum(self, sum: Sum, **kw) -> Sum: ...
+        for index, clause in enumerate(columns):
+            # We need to avoid wrapped columns with `` or '' when clause hasn't table
+            if isinstance(columns, str):
+                string_columns = f"{columns} {str(order._order_type[0])}"
+                return f"{ORDER} {string_columns}"
+
+            if not clause.table:
+                string_column = clause.compile(
+                    self.dialect,
+                    table=None,
+                    alias_clause=None,
+                    literal=True,
+                ).string
+            else:
+                string_column = clause.compile(self.dialect, alias_clause=None).string
+
+            string_columns.append(f"{string_column} {str(order._order_type[index])}")
+
+        return f"{ORDER} {', '.join(string_columns)}"
+
+    def visit_concat(self, concat: Concat, **kw) -> Concat:
+        columns: list[str] = []
+
+        for clause in concat.values:
+            if isinstance(clause, ColumnProxy):
+                compiled = clause.compile(self.dialect, alias_clause=None).string
+            else:
+                compiled = f"'{clause}'"
+            columns.append(compiled)
+
+        clause_info = ClauseInfo(
+            table=None,
+            column=f"CONCAT({', '.join(columns)})",
+            alias_clause=concat.alias,
+            dialect=self.dialect,
+        )
+        return clause_info.query(self.dialect)
+
+    def visit_max(self, max: Max, **kw) -> str:
+        attr = {**kw, "alias_clause": None}
+        column = max.column.compile(self.dialect, **attr).string
+        return ClauseInfo.concat_alias_and_column(f"MAX({column})", max.alias)
+
+    def visit_min(self, min: Min, **kw) -> str:
+        attr = {**kw, "alias_clause": None}
+        column = min.column.compile(self.dialect, **attr).string
+        return ClauseInfo.concat_alias_and_column(f"MIN({column})", min.alias)
+
+    def visit_sum(self, sum: Sum, **kw) -> str:
+        attr = {**kw, "alias_clause": None}
+        column = sum.column.compile(self.dialect, **attr).string
+        return ClauseInfo.concat_alias_and_column(f"SUM({column})", sum.alias)
+
+    def visit_st_astext(self, st_astext: ST_AsText) -> str:
+        # avoid use placeholder when using IAggregate because no make sense.
+        if st_astext.alias and (found := ClauseInfo._keyRegex.findall(st_astext.alias)):
+            raise NotKeysInIAggregateError(found)
+        return ClauseInfo.concat_alias_and_column(f"ST_AsText({st_astext.column.compile(self.dialect, alias_clause=None).string})", st_astext.alias)
+
+    def visit_st_contains(self, st_contains: ST_Contains) -> str:
+        attr1 = st_contains.column.compile(self.dialect, alias_clause=None).string
+        attr2 = ClauseInfo(None, st_contains.point, dialect=self.dialect).query(self.dialect, alias_clause=None)
+        return f"ST_Contains({attr1}, {attr2})"
 
 
 class MySQLDDLCompiler(compiler.DDLCompiler):
@@ -149,6 +329,12 @@ class MySQLDDLCompiler(compiler.DDLCompiler):
 
         return colspec
 
+    def visit_foreign_key(self, fk: ForeignKey, **kw) -> str:
+        compare = fk.resolved_function()
+        lcon = compare.left_condition
+        rcon = compare.right_condition
+        return f"FOREIGN KEY ({lcon.column_name}) REFERENCES {rcon.table.__table_name__}({rcon.column_name})"
+
 
 class MySQLTypeCompiler(compiler.GenericTypeCompiler):
     def mysql_type(self, type_: Any) -> bool:

ormlambda/dialects/mysql/clauses/ST_AsText.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from ormlambda.sql.clause_info import IAggregate
+from ormlambda.sql.types import ColumnType, AliasType
+
+from ormlambda.sql.elements import ClauseElement
+
+
+class ST_AsText[T, TProp](ClauseElement, IAggregate):
+    """
+    https://dev.mysql.com/doc/refman/8.4/en/fetching-spatial-data.html
+
+    The ST_AsText() function converts a geometry from internal format to a WKT string.
+    """
+
+    __visit_name__ = "st_astext"
+
+    def __init__(self, point: ColumnType[TProp], alias: AliasType[TProp] = "st_astext") -> None:
+        self.alias = alias
+        self.column = point
+
+    def used_columns(self):
+        return [self.column]
+
+    @property
+    def dtype(self) -> str:
+        return str

ormlambda/dialects/mysql/clauses/ST_Contains.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+import typing as tp
+
+from shapely import Point
+
+from ormlambda import Column
+from ormlambda.sql.types import ColumnType, AliasType
+from ormlambda.sql.clause_info import IAggregate
+from ormlambda.sql.elements import ClauseElement
+
+
+class ST_Contains(ClauseElement, IAggregate):
+    __visit_name__ = "st_contains"
+
+    def __init__[TProp: Column](
+        self,
+        column: ColumnType[TProp],
+        point: Point,
+        alias: AliasType[ColumnType[TProp]] = "st_contains",
+    ):
+        self.column = column
+        self.point = point
+        self.alias = alias
+
+    @property
+    def dtype(self) -> str:
+        return str
+
+    def used_columns(self) -> tp.Iterable:
+        return [self.attr1]

ormlambda/dialects/mysql/clauses/__init__.py

@@ -0,0 +1 @@
+from .ST_AsText import ST_AsText as ST_AsText

ormlambda/dialects/mysql/repository/__init__.py

@@ -0,0 +1 @@
+from .repository import MySQLRepository  # noqa: F401

ormlambda/{databases/my_sql → dialects/mysql/repository}/repository.py

@@ -10,7 +10,6 @@ from mysql.connector.pooling import MySQLConnectionPool  # noqa: F401
 from ormlambda.repository import BaseRepository
 
 # Custom libraries
-from .clauses import DropTable
 from ormlambda.repository.response import Response
 from ormlambda.caster import Caster
 
@@ -167,10 +166,6 @@ class MySQLRepository(BaseRepository[MySQLConnectionPool]):
                 cursor.execute(query)
         return None
 
-    @override
-    def drop_table(self, name: str) -> None:
-        return DropTable(self).execute(name)
-
     @override
     def database_exists(self, name: str) -> bool:
         temp_config = self._pool._cnx_config

ormlambda/dialects/mysql/types.py

@@ -11,6 +11,9 @@ import datetime
 
 from ormlambda.sql import sqltypes
 
+# to be able to import the same object with different dialect
+from ormlambda.sql.sqltypes import POINT  # noqa: F401
+
 
 class _NumericCommonType:
     """Base for MySQL numeric types.
@@ -231,6 +234,9 @@ class INTEGER(_IntegerType, sqltypes.INTEGER):
         super().__init__(display_width=display_width, **kw)
 
 
+INT = INTEGER
+
+
 class BIGINT(_IntegerType, sqltypes.BIGINT):
     """MySQL BIGINTEGER type."""
 

ormlambda/engine/base.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING, Literal
+from pathlib import Path
+from typing import TYPE_CHECKING, BinaryIO, Literal, Optional, TextIO
 from ormlambda.engine import url
-from ormlambda.sql.ddl import CreateSchema, DropSchema
-
+from ormlambda.sql.ddl import CreateSchema, DropSchema, CreateBackup
 
 if TYPE_CHECKING:
     from ormlambda.dialects import Dialect
@@ -16,11 +16,14 @@ class Engine:
         self.url = url
         self.repository = self.dialect.repository_cls(url, dialect=dialect)
 
+    def __repr__(self):
+        return f"{Engine.__name__}: {self.url}"
+
     def create_schema(self, schema_name: str, if_exists: TypeExists = "fail") -> None:
         if if_exists == "replace":
             self.drop_schema(schema_name, if_exists)
 
-        sql = CreateSchema(schema=schema_name, if_not_exists=if_exists== 'append').compile(self.dialect).string
+        sql = CreateSchema(schema=schema_name, if_not_exists=if_exists == "append").compile(self.dialect).string
         try:
             self.repository.execute(sql)
         except Exception:
@@ -56,3 +59,22 @@ class Engine:
     def set_database(self, name: str) -> None:
         self.repository.database = name
         return None
+
+    def create_backup(
+        self,
+        output: Optional[str | BinaryIO | TextIO] = None,
+        compress: bool = False,
+        backup_dir: str = "backups",
+        **kw,
+    ) -> Optional[str | BinaryIO | Path]:
+        return (
+            CreateBackup(self.url)
+            .compile(
+                self.dialect,
+                output=output,
+                compress=compress,
+                backup_dir=backup_dir,
+                **kw,
+            )
+            .string
+        )

ormlambda/errors.py

@@ -15,3 +15,12 @@ class NoSuchModuleError(Exception):
 
     def __str__(self):
         return f"NoSuchModuleError: {self.args[0]}"
+
+
+class DuplicatedClauseName(Exception):
+    def __init__(self, names: tuple[str], **kw):
+        self.names = names
+        super().__init__(**kw)
+
+    def __str__(self):
+        return f"Some clauses has the same alias. {self.names}\nTry wrapping the clause with the 'Alias' class first or setting 'avoid_duplicate' param as 'True'"

ormlambda/model/base_model.py

@@ -7,22 +7,15 @@ from ormlambda.statements import Statements
 from ormlambda.engine import Engine
 
 if TYPE_CHECKING:
-    from ormlambda.statements.interfaces import IStatements_two_generic
-
-
-# endregion
+    from ormlambda.statements.interfaces import IStatements
 
 
 class BaseModel[T]:
     """
-    Class to select the correct BaseStatement class depends on the repository.
-
-    Contiene los metodos necesarios para hacer consultas a una tabla
+    This class contains those methods to make query to a table
     """
 
-    # region Constructor
-
-    def __new__[TPool](cls, model: Type[T], engine: Engine) -> IStatements_two_generic[T, TPool]:
+    def __new__(cls, model: Type[T], engine: Engine) -> IStatements[T]:
         if engine is None:
             raise ValueError("`None` cannot be passed to the `repository` attribute when calling the `BaseModel` class")
 

ormlambda/repository/base_repository.py

@@ -5,7 +5,7 @@ import abc
 
 if TYPE_CHECKING:
     from ormlambda import URL as _URL
-    from ormlambda.dialects.interface.dialect import Dialect
+    from ormlambda.dialects import Dialect
 
 
 class BaseRepository[TPool](IRepositoryBase):

ormlambda/repository/interfaces/IRepositoryBase.py

@@ -9,12 +9,8 @@ from typing import (
     Sequence,
     Type,
     Iterable,
-    TYPE_CHECKING,
 )
 
-if TYPE_CHECKING:
-    from ormlambda.statements.types import TypeExists
-
 
 type _DBAPICursorDescription = Sequence[
     tuple[
@@ -142,9 +138,6 @@ class IRepositoryBase(ABC):
     @abstractmethod
     def execute(self, query: str) -> None: ...
 
-    @abstractmethod
-    def drop_table(self, name: str) -> None: ...
-
     @abstractmethod
     def table_exists(self, name: str) -> bool: ...
 

ormlambda/repository/response.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 from typing import Type, Any, TYPE_CHECKING, Optional
-from ormlambda.dialects.interface.dialect import Dialect
+from ormlambda.dialects import Dialect
 import shapely as shp
 
 # Custom libraries
 from ormlambda.sql.clauses import Alias
 
 if TYPE_CHECKING:
-    from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo
+    from ormlambda.sql.clause_info import ClauseInfo
     from ormlambda import Table
     from ormlambda.sql.clauses import Select
 
@@ -88,10 +88,15 @@ class Response[TFlavour, *Ts]:
             nonlocal data
             replacer_dicc: dict[str, str] = {}
 
-            for col in self._select.all_clauses:
-                if hasattr(col, "_alias_aggregate") or col.alias_clause is None or isinstance(col, Alias):
+            for col in self._select.columns:
+                if isinstance(col, Alias):
                     continue
-                replacer_dicc[col.alias_clause] = col.column
+
+                if hasattr(col, "alias"):
+                    continue
+
+                alias = col.alias if col.alias else col.get_full_chain("_")
+                replacer_dicc[alias] = col.column_name
 
             cleaned_column_names = [replacer_dicc.get(col, col) for col in self._columns]
 
@@ -116,8 +121,8 @@ class Response[TFlavour, *Ts]:
             new_row: list = []
             for i, data in enumerate(row):
                 alias = self._columns[i]
-                clause_info = self._select[alias]
-                parse_data = self._caster.for_value(data, value_type=clause_info.dtype).from_database
+                clause = self._select[alias]
+                parse_data = self._caster.for_value(data, value_type=clause.dtype).from_database
                 new_row.append(parse_data)
             new_row = tuple(new_row)
             if not isinstance(new_row, tuple):

ormlambda/sql/__init__.py

@@ -1,3 +1,12 @@
-from .column import Column as Column
-from .foreign_key import ForeignKey as ForeignKey
-from .table import Table as Table
+from .column import Column, ColumnProxy
+from .foreign_key import ForeignKey
+from .table import Table, TableProxy
+
+
+__all__ = (
+    "Column",
+    "ColumnProxy",
+    "ForeignKey",
+    "Table",
+    "TableProxy",
+)

ormlambda/sql/clause_info/__init__.py

@@ -1,4 +1,2 @@
 from .interface import IAggregate  # noqa: F401
 from .clause_info import ClauseInfo  # noqa: F401
-from .aggregate_function_base import AggregateFunctionBase  # noqa: F401
-from .clause_info_context import ClauseContextType, ClauseInfoContext  # noqa: F401