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

ormlambda/databases/my_sql/caster/types/string.py

@@ -1,19 +1,19 @@
 from typing import Optional
-from ormlambda.caster import BaseCaster, PLACEHOLDER
+from ormlambda.caster import BaseCaster, Caster
 
 
 class StringCaster[TType](BaseCaster[str, TType]):
     def __init__(self, value: str, type_value: TType):
         super().__init__(value, type_value)
 
-    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
-        return value
+    def wildcard_to_select(self, value: Optional[str] = None) -> str:
+        return Caster.PLACEHOLDER if value is None else value
 
-    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
-        return value
+    def wildcard_to_where(self, value: Optional[str] = None) -> str:
+        return Caster.PLACEHOLDER if value is None else value
 
-    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
-        return value
+    def wildcard_to_insert(self, value: Optional[str] = None) -> str:
+        return Caster.PLACEHOLDER if value is None else value
 
     @property
     @BaseCaster.return_value_if_exists

ormlambda/databases/my_sql/clauses/ST_AsText.py

@@ -1,7 +1,12 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
 from ormlambda.sql.clause_info import AggregateFunctionBase
 from ormlambda.sql.types import ColumnType, AliasType
 from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
 
+if TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
 
 class ST_AsText[T, TProp](AggregateFunctionBase[None]):
     """
@@ -20,16 +25,12 @@ class ST_AsText[T, TProp](AggregateFunctionBase[None]):
         alias_table: AliasType[ColumnType[TProp]] = None,
         alias_clause: AliasType[ColumnType[TProp]] = None,
         context: ClauseContextType = None,
+        *,
+        dialect: Dialect,
     ) -> None:
         default_alias_clause = self.create_alias_from(point) if not alias_clause else alias_clause
 
-        super().__init__(
-            table=point.table,
-            column=point,
-            alias_table=alias_table,
-            alias_clause=default_alias_clause,
-            context=context,
-        )
+        super().__init__(table=point.table, column=point, alias_table=alias_table, alias_clause=default_alias_clause, context=context, dialect=dialect)
 
     @staticmethod
     def create_alias_from(element: ColumnType[TProp]) -> str:

ormlambda/databases/my_sql/clauses/ST_Contains.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import typing as tp
 
 from shapely import Point
@@ -6,6 +7,9 @@ from ormlambda import Column
 from ormlambda.sql.types import ColumnType, AliasType
 from ormlambda.sql.clause_info import ClauseInfo, IAggregate
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
 
 class ST_Contains(IAggregate):
     FUNCTION_NAME: str = "ST_Contains"
@@ -16,15 +20,16 @@ class ST_Contains(IAggregate):
         point: Point,
         alias_table: tp.Optional[AliasType[ColumnType[TProp]]] = None,
         alias_clause: tp.Optional[AliasType[ColumnType[TProp]]] = None,
+        *,
+        dialect: Dialect,
     ):
-        self.attr1: ClauseInfo[Point] = ClauseInfo(column.table, column, alias_table)
-        self.attr2: ClauseInfo[Point] = ClauseInfo[Point](None, point)
+        self.attr1: ClauseInfo[Point] = ClauseInfo(column.table, column, alias_table, dialect=dialect)
+        self.attr2: ClauseInfo[Point] = ClauseInfo[Point](None, point, dialect=dialect)
 
         self._alias_clause: AliasType[ColumnType[TProp]] = alias_clause
 
-    @property
-    def query(self) -> str:
-        return f"{self.FUNCTION_NAME}({self.attr1.query}, {self.attr2.query})"
+    def query(self, dialect: Dialect, **kwargs) -> str:
+        return f"{self.FUNCTION_NAME}({self.attr1.query(dialect,**kwargs)}, {self.attr2.query(dialect,**kwargs)})"
 
     @property
     def alias_clause(self) -> tp.Optional[str]:

ormlambda/databases/my_sql/clauses/__init__.py

@@ -1,20 +1,14 @@
-from .create_database import CreateDatabase as CreateDatabase
-from .create_database import TypeExists as TypeExists
-from .delete import DeleteQuery as DeleteQuery
-from .drop_database import DropDatabase as DropDatabase
+from .delete import DeleteQuery as Delete
 from .drop_table import DropTable as DropTable
-from .insert import InsertQuery as InsertQuery
+from .insert import InsertQuery as Insert
 from .joins import JoinSelector as JoinSelector
-from .joins import JoinType as JoinType
 from .limit import Limit as Limit
 from .offset import Offset as Offset
 from .order import Order as Order
-from .update import UpdateQuery as UpdateQuery
-from .upsert import UpsertQuery as UpsertQuery
+from .update import Update as Update
+from .upsert import UpsertQuery as Upsert
 from .where import Where as Where
 from .having import Having as Having
 from .count import Count as Count
 from .group_by import GroupBy as GroupBy
-from .alias import Alias as Alias
 from .ST_AsText import ST_AsText as ST_AsText
-from .select import Select as Select

ormlambda/databases/my_sql/clauses/count.py

@@ -1,25 +1,19 @@
 from __future__ import annotations
-from ormlambda.sql.clause_info import AggregateFunctionBase
+from ormlambda.sql.clauses import Count
 from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
 
 from ormlambda.sql.types import AliasType, ColumnType
 
 from ormlambda import Table
 
-import typing as tp
+from typing import TYPE_CHECKING
 
-from ormlambda.sql.types import ASTERISK
-
-if tp.TYPE_CHECKING:
+if TYPE_CHECKING:
     from ormlambda import Table
     from ormlambda.sql.types import ColumnType, AliasType, TableType
 
 
-class Count[T: Table](AggregateFunctionBase[T]):
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "COUNT"
-
+class Count[T: Table](Count[T]):
     def __init__[TProp: Table](
         self,
         element: ColumnType[T] | TableType[TProp],
@@ -29,12 +23,8 @@ class Count[T: Table](AggregateFunctionBase[T]):
         keep_asterisk: bool = True,
         preserve_context: bool = True,
     ) -> None:
-        table = self.extract_table(element)
-        column = element if self.is_column(element) else ASTERISK
-
         super().__init__(
-            table=table if (alias_table or (context and table in context._table_context)) else None,
-            column=column,
+            element=element,
             alias_table=alias_table,
             alias_clause=alias_clause,
             context=context,

ormlambda/databases/my_sql/clauses/delete.py

@@ -1,56 +1,9 @@
-from typing import Any, Optional, override, Iterable, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ormlambda import Column
-
 from ormlambda import Table
 from ormlambda.repository import IRepositoryBase
-from ormlambda.components.delete import DeleteQueryBase
+from ormlambda.sql.clauses import Delete
+from mysql.connector import MySQLConnection
 
 
-class DeleteQuery[T: Table](DeleteQueryBase[T, IRepositoryBase]):
+class DeleteQuery[T: Table](Delete[T, MySQLConnection]):
     def __init__(self, model: T, repository: IRepositoryBase) -> None:
         super().__init__(model, repository)
-
-    @property
-    def CLAUSE(self) -> str:
-        return "DELETE"
-
-    @override
-    def delete(self, instances: T | list[T]) -> None:
-        col: str = ""
-        if isinstance(instances, Table):
-            pk: Optional[Column] = instances.get_pk()
-            if pk is None:
-                raise Exception(f"You cannot use 'DELETE' query without set primary key in '{instances.__table_name__}'")
-            col = pk.column_name
-            value = str(instances[pk])
-
-        elif isinstance(instances, Iterable):
-            value: list[Any] = []
-            for ins in instances:
-                pk = type(ins).get_pk()
-                value.append(ins[pk])
-            col = pk.column_name
-
-        query: str = f"{self.CLAUSE} FROM {self._model.__table_name__} WHERE {col}"
-        if isinstance(value, str):
-            query += "= %s"
-            self._query = query
-            self._values = [value]
-            return None
-
-        elif isinstance(value, Iterable):
-            params = ", ".join(["%s"] * len(value))
-            query += f" IN ({params})"
-            self._query = query
-            self._values = value
-            return None
-        else:
-            raise Exception(f"'{type(value)}' no esperado")
-
-    @override
-    def execute(self) -> None:
-        if not self._query:
-            raise ValueError
-        return self._repository.execute_with_values(self._query, self._values)

ormlambda/databases/my_sql/clauses/group_by.py

@@ -1,14 +1,9 @@
-import typing as tp
-from ormlambda import Table
-from ormlambda.sql.clause_info import AggregateFunctionBase, ClauseInfoContext
+from ormlambda.sql.clause_info import ClauseInfoContext
+from ormlambda.sql.clauses import GroupBy
 from ormlambda.sql.types import ColumnType
 
 
-class GroupBy[T: tp.Type[Table], *Ts, TProp](AggregateFunctionBase):
-    @classmethod
-    def FUNCTION_NAME(self) -> str:
-        return "GROUP BY"
-
+class GroupBy(GroupBy):
     def __init__(
         self,
         column: ColumnType,
@@ -16,15 +11,7 @@ class GroupBy[T: tp.Type[Table], *Ts, TProp](AggregateFunctionBase):
         **kwargs,
     ):
         super().__init__(
-            table=column.table,
             column=column,
-            alias_table=None,
-            alias_clause=None,
             context=context,
             **kwargs,
         )
-
-    @property
-    def query(self) -> str:
-        column = self._create_query()
-        return f"{self.FUNCTION_NAME()} {column}"

ormlambda/databases/my_sql/clauses/having.py

@@ -1,16 +1,12 @@
 from __future__ import annotations
 
-from .where import Where
+from ormlambda.sql.clauses import Having
 
 
-class Having(Where):
+class Having(Having):
     """
     The purpose of this class is to create 'WHERE' condition queries properly.
     """
 
     def __init__(self, *comparer, restrictive=True, context=None):
         super().__init__(*comparer, restrictive=restrictive, context=context)
-
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "HAVING"

ormlambda/databases/my_sql/clauses/insert.py

@@ -1,97 +1,9 @@
 from __future__ import annotations
-
-from typing import override, Iterable, TYPE_CHECKING
-
 from ormlambda import Table
-from ormlambda import Column
-from ormlambda.components.insert import InsertQueryBase
-from ormlambda.repository import IRepositoryBase
-from ormlambda.caster import Caster
-
-if TYPE_CHECKING:
-    from ormlambda.databases.my_sql import MySQLRepository
+from ormlambda.sql.clauses import Insert
+from mysql.connector import MySQLConnection
 
 
-class InsertQuery[T: Table](InsertQueryBase[T, IRepositoryBase]):
-    def __init__(self, model: T, repository: MySQLRepository) -> None:
+class InsertQuery[T: Table](Insert[T, MySQLConnection]):
+    def __init__(self, model, repository):
         super().__init__(model, repository)
-
-    @override
-    @property
-    def CLAUSE(self) -> str:
-        return "INSERT INTO"
-
-    @override
-    def execute(self) -> None:
-        if not self._query:
-            raise ValueError
-        return self._repository.executemany_with_values(self.query, self._values)
-
-    @override
-    def insert[TProp](self, instances: T | list[T]) -> None:
-        if not isinstance(instances, Iterable):
-            instances = (instances,)
-        valid_cols: list[list[Column[TProp]]] = []
-        self.__fill_dict_list(valid_cols, instances)
-
-        col_names: list[str] = []
-        wildcards: list[str] = []
-        col_values: list[list[str]] = []
-        for i, cols in enumerate(valid_cols):
-            col_values.append([])
-            CASTER = Caster(self._repository)
-            for col in cols:
-                clean_data = CASTER.for_column(col, instances[i])  # .resolve(instances[i][col])
-                if i == 0:
-                    col_names.append(col.column_name)
-                    wildcards.append(clean_data.wildcard_to_insert())
-                # COMMENT: avoid MySQLWriteCastBase.resolve when using PLACEHOLDERs
-                col_values[-1].append(clean_data.to_database)
-
-        join_cols = ", ".join(col_names)
-        unknown_rows = f'({", ".join(wildcards)})'  # The number of "%s" must match the dict 'dicc_0' length
-
-        self._values = [tuple(x) for x in col_values]
-        self._query = f"{self.CLAUSE} {self._model.__table_name__} {f'({join_cols})'} VALUES {unknown_rows}"
-        return None
-
-    @staticmethod
-    def __is_valid[TProp](column: Column[TProp], value: TProp) -> bool:
-        """
-        We want to delete the column from table when it's specified with an 'AUTO_INCREMENT' or 'AUTO GENERATED ALWAYS AS (__) STORED' statement.
-
-        if the column is auto-generated, it means the database creates the value for that column, so we must deleted it.
-        if the column is primary key and auto-increment, we should be able to create an object with specific pk value.
-
-        RETURN
-        -----
-
-        - True  -> Do not delete the column from dict query
-        - False -> Delete the column from dict query
-        """
-
-        is_pk_none_and_auto_increment: bool = all([value is None, column.is_primary_key, column.is_auto_increment])
-
-        if is_pk_none_and_auto_increment or column.is_auto_generated:
-            return False
-        return True
-
-    def __fill_dict_list[TProp](self, list_dict: list[str, TProp], values: list[T]) -> list[Column]:
-        if isinstance(values, Iterable):
-            for x in values:
-                self.__fill_dict_list(list_dict, x)
-
-        elif issubclass(values.__class__, Table):
-            new_list = []
-            for prop in type(values).__dict__.values():
-                if not isinstance(prop, Column):
-                    continue
-
-                value = getattr(values, prop.column_name)
-                if self.__is_valid(prop, value):
-                    new_list.append(prop)
-            list_dict.append(new_list)
-
-        else:
-            raise Exception(f"Tipo de dato'{type(values)}' no esperado")
-        return None

ormlambda/databases/my_sql/clauses/joins.py

@@ -1,149 +1,14 @@
 from __future__ import annotations
-from collections import defaultdict
-from typing import override, Optional, TYPE_CHECKING, Type
+from typing import TYPE_CHECKING
 
 
-from ormlambda.utils.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.clauses import JoinSelector
 
 # TODOL [x]: Try to import Table module without circular import Error
 if TYPE_CHECKING:
     from ormlambda import Table
 
 
-class JoinSelector[TLeft: Table, TRight: Table](IJoinSelector[TLeft, TRight]):
-    __slots__: tuple = (
-        "_comparer",
-        "_orig_table",
-        "_right_table",
-        "_by",
-        "_left_col",
-        "_right_col",
-        "_compareop",
-        "_alias",
-    )
-
-    @override
-    def __repr__(self) -> str:
-        table_col_left: str = f"{self.left_table.table_alias()}.{self._left_col}"
-        table_col_right: str = f"{self.right_table.table_alias()}.{self._right_col}"
-
-        return f"{IQuery.__name__}: {self.__class__.__name__} ({table_col_left} == {table_col_right})"
-
-    def __init__[LProp, RProp](
-        self,
-        where: Comparer[TLeft, LProp, TRight, RProp],
-        by: JoinType,
-        alias: Optional[str] = "{table}",
-        context: ClauseContextType = None,
-    ) -> 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
-        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._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())
-
-    def __eq__(self, __value: JoinSelector) -> bool:
-        return isinstance(__value, JoinSelector) and self.__hash__() == __value.__hash__()
-
-    def __hash__(self) -> int:
-        return hash(
-            (
-                self.left_table,
-                self.right_table,
-                self._by,
-                self._left_col,
-                self._right_col,
-                self._compareop,
-            )
-        )
-
-    def _create_partial_context(self) -> ClauseInfoContext:
-        """
-        Only use table_context from global context
-        """
-        if not self._context:
-            return ClauseInfoContext()
-        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])
-
-    @property
-    @override
-    def query(self) -> str:
-        self._context = ClauseInfoContext(clause_context=None, table_context=self._context._table_context)
-        list_ = [
-            self._by.value,  # inner join
-            self._from_clause.query,
-            "ON",
-            self._left_table_clause.query,
-            self._compareop,  # =
-            self._right_table_clause.query,
-        ]
-        return " ".join([x for x in list_ if x is not None])
-
-    @property
-    def left_table(self) -> TLeft:
-        return self._orig_table
-
-    @property
-    def right_table(self) -> TRight:
-        return self._right_table
-
-    @property
-    def left_col(self) -> str:
-        return self._left_col
-
-    @property
-    def right_col(self) -> str:
-        return self._right_col
-
-    @property
-    def alias(self) -> str:
-        return self._alias
-
-    @classmethod
-    def sort_join_selectors(cls, joins: set[JoinSelector]) -> tuple[JoinSelector]:
-        # FIXME [x]: How to sort when needed because it's not necessary at this point. It is for testing purpouse
-        if len(joins) == 1:
-            return tuple(joins)
-
-        join_object_map: dict[str, list[JoinSelector]] = defaultdict(list)
-
-        for obj in joins:
-            join_object_map[obj.left_table].append(obj)
-
-        graph: dict[Type[Table], list[Type[Table]]] = defaultdict(list)
-        for join in joins:
-            graph[join.left_table].append(join.right_table)
-
-        sorted_graph = DFSTraversal.sort(graph)[::-1]
-
-        if not sorted_graph:
-            return tuple(joins)
-
-        res = []
-        for table in sorted_graph:
-            tables = join_object_map[table]
-
-            if not tables:
-                continue
-            res.extend(tables)
-        return res
+class JoinSelector[TLeft: Table, TRight: Table](JoinSelector[TLeft, TRight]):
+    def __init__(self, where, by, alias="{table}", context=None, **kw):
+        super().__init__(where, by, alias, context, **kw)

ormlambda/databases/my_sql/clauses/limit.py

@@ -1,17 +1,6 @@
-from typing import override
+from ormlambda.sql.clauses import Limit
 
-from ormlambda.common.interfaces.IQueryCommand import IQuery
 
-
-class Limit(IQuery):
-    LIMIT = "LIMIT"
-
-    def __init__(self, number: int) -> None:
-        if not isinstance(number, int):
-            raise ValueError
-        self._number: int = number
-
-    @override
-    @property
-    def query(self) -> str:
-        return f"{self.LIMIT} {self._number}"
+class Limit(Limit):
+    def __init__(self, number):
+        super().__init__(number)

ormlambda/databases/my_sql/clauses/offset.py

@@ -1,17 +1,6 @@
-from typing import override
+from ormlambda.sql.clauses import Offset
 
-from ormlambda.common.interfaces.IQueryCommand import IQuery
 
-
-class Offset(IQuery):
-    OFFSET = "OFFSET"
-
-    def __init__(self, number: int) -> None:
-        if not isinstance(number, int):
-            raise ValueError
-        self._number: int = number
-
-    @override
-    @property
-    def query(self) -> str:
-        return f"{self.OFFSET} {self._number}"
+class Offset(Offset):
+    def __init__(self, number):
+        super().__init__(number)

ormlambda/databases/my_sql/clauses/order.py

@@ -1,65 +1,8 @@
 from __future__ import annotations
-import typing as tp
 
-from ormlambda.sql.clause_info.clause_info_context import ClauseInfoContext, ClauseContextType
-from ormlambda.sql.types import ColumnType
-from ormlambda.sql.clause_info import AggregateFunctionBase
+from ormlambda.sql.clauses import Order
 
-from ormlambda.statements import OrderType
 
-
-class Order(AggregateFunctionBase):
-    @staticmethod
-    def FUNCTION_NAME() -> str:
-        return "ORDER BY"
-
-    def __init__[TProp](
-        self,
-        column: tuple[ColumnType[TProp], ...] | ColumnType[TProp],
-        order_type: tp.Iterable[OrderType],
-        context: ClauseContextType = None,
-    ):
-        super().__init__(
-            table=None,
-            column=column,
-            context=context,
-        )
-
-        if isinstance(order_type, str) or not isinstance(order_type, tp.Iterable):
-            order_type = (order_type,)
-
-        self._order_type: list[OrderType] = [self.__cast_to_OrderType(x) for x in order_type]
-
-    def __cast_to_OrderType(self, _value: tp.Any) -> tp.Iterable[OrderType]:
-        if isinstance(_value, OrderType):
-            return _value
-
-        if isinstance(_value, str):
-            try:
-                return OrderType(_value)
-            except Exception:
-                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)}"
+class Order(Order):
+    def __init__(self, column, order_type, context=None):
+        super().__init__(column, order_type, context)