ormlambda 2.11.1__py3-none-any.whl → 3.7.0__py3-none-any.whl

ormlambda/common/interfaces/IJoinSelector.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+import abc
+
+
+from .IQueryCommand import IQuery
+
+
+class IJoinSelector[TLeft, TRight](IQuery):
+    @abc.abstractmethod
+    def sort_join_selectors(cls, joins: set[IJoinSelector]) -> tuple[IJoinSelector]: ...
+
+    @property
+    def left_table(self) -> str: ...
+    @property
+    def right_table(self) -> str: ...
+    @property
+    def left_col(self) -> str: ...
+    @property
+    def right_col(self) -> str: ...
+    @property
+    def alias(self) -> str: ...

ormlambda/common/interfaces/__init__.py

@@ -1,7 +1,5 @@
-from .IQueryCommand import IQuery as IQuery
-from .INonQueryCommand import INonQueryCommand as INonQueryCommand
-from .IRepositoryBase import IRepositoryBase as IRepositoryBase
-from .IStatements import IStatements as IStatements, IStatements_two_generic as IStatements_two_generic
-from .IDecompositionQuery import IDecompositionQuery as IDecompositionQuery
-from .IAggregate import IAggregate as IAggregate
 from .ICustomAlias import ICustomAlias as ICustomAlias
+from .IDecompositionQuery import IDecompositionQuery as IDecompositionQuery
+from .IJoinSelector import IJoinSelector as IJoinSelector
+from .INonQueryCommand import INonQueryCommand as INonQueryCommand
+from .IQueryCommand import IQuery as IQuery

ormlambda/components/__init__.py

@@ -0,0 +1,4 @@
+from .select import ISelect  # noqa: F401
+from .delete import IDelete  # noqa: F401
+from .insert import IInsert  # noqa: F401
+from .update import IUpdate  # noqa: F401

ormlambda/components/insert/abstract_insert.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ormlambda import Table
-    from ormlambda import IRepositoryBase
+    from ormlambda.repository import IRepositoryBase
 
 from ormlambda.common.abstract_classes import NonQueryBase
 from .IInsert import IInsert

ormlambda/components/select/ISelect.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+import abc
+from ormlambda.common.interfaces import IQuery
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda.sql.clause_info import ClauseInfo
+
+class ISelect(IQuery):
+    @property
+    @abc.abstractmethod
+    def FROM(self)->ClauseInfo: ...
+    
+    @property
+    @abc.abstractmethod
+    def COLUMNS(self)->str: ...
+

ormlambda/components/select/__init__.py

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

ormlambda/components/update/abstract_update.py

@@ -2,20 +2,20 @@ from __future__ import annotations
 from abc import abstractmethod
 from typing import Any, Optional, TYPE_CHECKING
 
-from ormlambda.components.where import AbstractWhere
 from ormlambda.common.abstract_classes import NonQueryBase
+from ormlambda.databases.my_sql.clauses.where import Where
 
 if TYPE_CHECKING:
-    from ormlambda import IRepositoryBase
+    from ormlambda.repository import IRepositoryBase
     from ormlambda import Table
 
 from .IUpdate import IUpdate
 
 
 class UpdateQueryBase[T: Table, TRepo: IRepositoryBase](NonQueryBase[T, TRepo], IUpdate):
-    def __init__(self, model: T, repository: TRepo, where: AbstractWhere = list[AbstractWhere]) -> None:
+    def __init__(self, model: T, repository: TRepo, where: list[Where] = list[Where]) -> None:
         super().__init__(model, repository)
-        self._where: Optional[AbstractWhere] = where
+        self._where: Optional[list[Where]] = where
 
     @abstractmethod
     def update(self, dicc: dict[str | property, Any]) -> None:

ormlambda/components/upsert/abstract_upsert.py

@@ -3,7 +3,7 @@ from abc import abstractmethod
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from ormlambda import IRepositoryBase
+    from ormlambda.repository import IRepositoryBase
     from ormlambda import Table
 
 from ormlambda.common.abstract_classes import NonQueryBase

ormlambda/databases/__init__.py

@@ -0,0 +1,5 @@
+from .my_sql import (
+    MySQLCaster as MySQLCaster,
+    MySQLRepository as MySQLRepository,
+    MySQLStatements as MySQLStatements,
+)

ormlambda/databases/my_sql/__init__.py

@@ -1,2 +1,4 @@
-from .repository import MySQLRepository, Error  # noqa: F401
+from mysql.connector import MySQLConnection  # noqa: F401
+from .repository import MySQLRepository  # noqa: F401
 from .statements import MySQLStatements  # noqa: F401
+from .caster import MySQLCaster  # noqa: F401

ormlambda/databases/my_sql/caster/__init__.py

@@ -0,0 +1 @@
+from .caster import MySQLCaster as MySQLCaster

ormlambda/databases/my_sql/caster/caster.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Optional, get_args
+from ormlambda.caster import BaseCaster
+from ormlambda.caster import ICaster
+
+
+from .types import StringCaster, IntegerCaster, FloatCaster, PointCaster, NoneTypeCaster, DatetimeCaster, BytesCaster, IterableCaster
+
+from shapely import Point
+from types import NoneType
+from datetime import datetime
+
+
+class MySQLCaster(ICaster):
+    @classmethod
+    def CASTER_SELECTOR(cls):
+        return {
+            str: StringCaster,
+            int: IntegerCaster,
+            float: FloatCaster,
+            Point: PointCaster,
+            NoneType: NoneTypeCaster,
+            datetime: DatetimeCaster,
+            bytes: BytesCaster,
+            tuple: IterableCaster,
+            list: IterableCaster,
+        }
+
+    @classmethod
+    def cast[TProp, TType](cls, value: TProp, type_value: Optional[TType] = None) -> BaseCaster[TProp, TType]:
+        if len(args := get_args(type_value)) > 1:
+            args = [x for x in args if x != NoneType]
+
+            type_value = args[0]
+
+        column_type = type_value if type_value else type(value)
+        return cls.CASTER_SELECTOR()[column_type](value, column_type)

ormlambda/databases/my_sql/caster/read.py

@@ -0,0 +1,39 @@
+from datetime import datetime
+from typing import Optional
+from shapely import Point
+from types import NoneType
+from ormlambda.common.abstract_classes.caster.cast_base import ReadCastBase
+
+
+from .types.datetime import MySQLReadDatetime
+from .types.string import MySQLReadString
+from .types.int import MySQLReadInt
+from .types.float import MySQLReadFloat
+from .types.point import MySQLReadPoint
+from .types.none import MySQLReadNoneType
+
+
+class MySQLReadCastBase(ReadCastBase):
+    @staticmethod
+    def cast_str(value: str) -> str:
+        return MySQLReadString.cast(value)
+
+    @staticmethod
+    def cast_int(value: str) -> int:
+        return MySQLReadInt.cast(value)
+
+    @staticmethod
+    def cast_float(value: str) -> float:
+        return MySQLReadFloat.cast(value)
+
+    @staticmethod
+    def cast_Point(value: str) -> Point:
+        return MySQLReadPoint.cast(value)
+
+    @staticmethod
+    def cast_NoneType(value: str) -> NoneType:
+        return MySQLReadNoneType.cast(value)
+
+    @staticmethod
+    def cast_datetime(value: str) -> datetime:
+        return MySQLReadDatetime.cast(value)

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

@@ -0,0 +1,8 @@
+from .string import StringCaster as StringCaster
+from .int import IntegerCaster as IntegerCaster
+from .float import FloatCaster as FloatCaster
+from .point import PointCaster as PointCaster
+from .none import NoneTypeCaster as NoneTypeCaster
+from .datetime import DatetimeCaster as DatetimeCaster
+from .bytes import BytesCaster as BytesCaster
+from .iterable import IterableCaster as IterableCaster

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

@@ -0,0 +1,31 @@
+from typing import Optional
+from ormlambda.caster import BaseCaster, PLACEHOLDER
+
+
+class BytesCaster[TType](BaseCaster[bytes, TType]):
+    def __init__(self, value: bytes, type_value: TType):
+        super().__init__(value, type_value)
+
+    def wildcard_to_select(self, value:str = PLACEHOLDER) -> str:
+        return value
+
+    def wildcard_to_where(self, value:str = PLACEHOLDER) -> str:
+        return value
+
+    def wildcard_to_insert(self, value:str = PLACEHOLDER) -> str:
+        return value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def to_database(self) -> Optional[bytes]:
+        return bytes(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def from_database(self) -> Optional[bytes]:
+        return bytes(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def string_data(self) -> Optional[str]:
+        return str(self.value)

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

@@ -0,0 +1,34 @@
+from typing import Optional
+from ormlambda.caster import BaseCaster, PLACEHOLDER
+from datetime import datetime
+from .string import StringCaster
+
+
+class DatetimeCaster[TType](BaseCaster[datetime, TType]):
+    def __init__(self, value: datetime, type_value: TType):
+        super().__init__(value, type_value)
+
+    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def to_database(self) -> Optional[datetime]:
+        return self.value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def from_database(self) -> Optional[datetime]:
+        return self.value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def string_data(self) -> Optional[str]:
+        datetime_string = self.value.strftime(r"%Y-%m-%d %H:%M:%S")
+        return StringCaster(datetime_string, str).string_data

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

@@ -0,0 +1,31 @@
+from typing import Optional
+from ormlambda.caster import BaseCaster, PLACEHOLDER
+
+
+class FloatCaster[TType](BaseCaster[float, TType]):
+    def __init__(self, value: float, type_value: TType):
+        super().__init__(value, type_value)
+
+    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def to_database(self) -> Optional[float]:
+        return float(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def from_database(self) -> Optional[float]:
+        return float(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def string_data(self) -> Optional[str]:
+        return str(self.value)

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

@@ -0,0 +1,31 @@
+from typing import Optional
+from ormlambda.caster import BaseCaster, PLACEHOLDER
+
+
+class IntegerCaster[TType](BaseCaster[int, TType]):
+    def __init__(self, value: int, type_value: TType):
+        super().__init__(value, type_value)
+
+    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def to_database(self) -> Optional[int]:
+        return int(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def from_database(self) -> Optional[int]:
+        return int(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def string_data(self) -> Optional[str]:
+        return str(self.value)

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

@@ -0,0 +1,31 @@
+from typing import Optional
+from ormlambda.caster import BaseCaster, PLACEHOLDER
+
+
+class IterableCaster[TType](BaseCaster[bytes, TType]):
+    def __init__(self, value: bytes, type_value: TType):
+        super().__init__(value, type_value)
+
+    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def to_database(self) -> Optional[bytes]:
+        return tuple(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def from_database(self) -> Optional[bytes]:
+        return tuple(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def string_data(self) -> Optional[str]:
+        return str(self.value)

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

@@ -0,0 +1,30 @@
+from types import NoneType
+from ormlambda.caster import BaseCaster, PLACEHOLDER
+
+
+class NoneTypeCaster[TType](BaseCaster[NoneType, TType]):
+    def __init__(self, value: NoneType, type_value: TType):
+        super().__init__(value, type_value)
+
+    def wildcard_to_select(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    def wildcard_to_where(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    def wildcard_to_insert(self, value:str=PLACEHOLDER) -> str:
+        return value
+
+    # TODOL: cheched if it's right
+    @property
+    def to_database(self) -> None:
+        return None
+
+    # TODOL: cheched if it's right
+    @property
+    def from_database(self) -> None:
+        return None
+
+    @property
+    def string_data(self) -> str:
+        return "NULL"

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

@@ -0,0 +1,43 @@
+from typing import Optional
+from ormlambda.caster import BaseCaster, PLACEHOLDER
+from shapely import Point
+import shapely.wkt as wkt
+from shapely import wkb
+
+
+class PointCaster[TType](BaseCaster[Point, TType]):
+    def __init__(self, value: bytes | str, type_value: TType):
+        super().__init__(value, type_value)
+
+    def wildcard_to_select(self, value: str = PLACEHOLDER) -> str:
+        return f"ST_AsText({value})"
+
+    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
+        return f"ST_AsText({value})"
+
+    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
+        return f"ST_GeomFromText({value})"
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def to_database(self) -> Optional[str]:
+        if isinstance(self.value, Point):
+            return self.value.wkt
+        return self.value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def from_database(self) -> Optional[Point]:
+        """
+        Always should get string because we're using 'ST_AsText' when calling wildcard_to_select prop.
+        """
+        if isinstance(self.value, bytes):
+            return wkb.loads(self.value)
+        elif isinstance(self.value, str):
+            return wkt.loads(self.value)
+        return self.value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def string_data(self) -> Optional[str]:
+        return type(self)(str(self.value), str).wildcard_to_select()

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

@@ -0,0 +1,31 @@
+from typing import Optional
+from ormlambda.caster import BaseCaster, PLACEHOLDER
+
+
+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_where(self, value:str = PLACEHOLDER) -> str:
+        return value
+
+    def wildcard_to_insert(self, value:str = PLACEHOLDER) -> str:
+        return value
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def to_database(self) -> Optional[str]:
+        return str(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def from_database(self) -> Optional[str]:
+        return str(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def string_data(self) -> Optional[str]:
+        return f"'{self.value}'"

ormlambda/databases/my_sql/caster/write.py

@@ -0,0 +1,37 @@
+from datetime import datetime
+from shapely import Point
+from types import NoneType
+from ormlambda.common.abstract_classes.caster.cast_base import WriteCastBase
+
+from .types.datetime import MySQLWriteDatetime
+from .types.string import MySQLWriteString
+from .types.int import MySQLWriteInt
+from .types.float import MySQLWriteFloat
+from .types.point import MySQLWritePoint
+from .types.none import MySQLWriteNoneType
+
+
+class MySQLWriteCastBase(WriteCastBase):
+    @staticmethod
+    def cast_str(value: str, insert_data: bool = False) -> str:
+        return MySQLWriteString.cast(value, insert_data)
+
+    @staticmethod
+    def cast_int(value: int, insert_data: bool = False) -> str:
+        return MySQLWriteInt.cast(value, insert_data)
+
+    @staticmethod
+    def cast_float(value: float, insert_data: bool = False) -> str:
+        return MySQLWriteFloat.cast(value, insert_data)
+
+    @staticmethod
+    def cast_Point(value: Point, insert_data: bool = False) -> str:
+        return MySQLWritePoint.cast(value, insert_data)
+
+    @staticmethod
+    def cast_NoneType(value: NoneType, insert_data: bool = False) -> str:
+        return MySQLWriteNoneType.cast(value, insert_data)
+
+    @staticmethod
+    def cast_datetime(value: datetime, insert_data: bool = False) -> str:
+        return MySQLWriteDatetime.cast(value, insert_data)

ormlambda/databases/my_sql/clauses/ST_AsText.py

@@ -0,0 +1,36 @@
+from ormlambda.sql.clause_info import AggregateFunctionBase
+from ormlambda.sql.types import ColumnType, AliasType
+from ormlambda.sql.clause_info.clause_info_context import ClauseContextType
+
+
+class ST_AsText[T, TProp](AggregateFunctionBase[None]):
+    """
+    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.
+    """
+
+    @staticmethod
+    def FUNCTION_NAME() -> str:
+        return "ST_AsText"
+
+    def __init__(
+        self,
+        point: ColumnType[TProp],
+        alias_table: AliasType[ColumnType[TProp]] = None,
+        alias_clause: AliasType[ColumnType[TProp]] = None,
+        context: ClauseContextType = None,
+    ) -> 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,
+        )
+
+    @staticmethod
+    def create_alias_from(element: ColumnType[TProp]) -> str:
+        return element.column_name

ormlambda/databases/my_sql/clauses/ST_Contains.py

@@ -0,0 +1,31 @@
+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 ClauseInfo, IAggregate
+
+
+class ST_Contains(IAggregate):
+    FUNCTION_NAME: str = "ST_Contains"
+
+    def __init__[TProp: Column](
+        self,
+        column: ColumnType[TProp],
+        point: Point,
+        alias_table: tp.Optional[AliasType[ColumnType[TProp]]] = None,
+        alias_clause: tp.Optional[AliasType[ColumnType[TProp]]] = None,
+    ):
+        self.attr1: ClauseInfo[Point] = ClauseInfo(column.table, column, alias_table)
+        self.attr2: ClauseInfo[Point] = ClauseInfo[Point](None, point)
+
+        self._alias_clause: AliasType[ColumnType[TProp]] = alias_clause
+
+    @property
+    def query(self) -> str:
+        return f"{self.FUNCTION_NAME}({self.attr1.query}, {self.attr2.query})"
+
+    @property
+    def alias_clause(self) -> tp.Optional[str]:
+        return self._alias_clause

ormlambda/databases/my_sql/clauses/__init__.py

@@ -6,12 +6,14 @@ from .drop_table import DropTable as DropTable
 from .insert import InsertQuery as InsertQuery
 from .joins import JoinSelector as JoinSelector
 from .joins import JoinType as JoinType
-from .limit import LimitQuery as LimitQuery
-from .offset import OffsetQuery as OffsetQuery
-from .order import OrderQuery as OrderQuery
+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 .where_condition import WhereCondition as WhereCondition
+from .where import Where as Where
 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/alias.py

@@ -1,31 +1,34 @@
+from __future__ import annotations
 import typing as tp
-from ormlambda.common.abstract_classes.decomposition_query import ClauseInfo, DecompositionQueryBase
-from ormlambda import Table
 
-from ormlambda.common.interfaces import ICustomAlias
+from ormlambda import Table, Column
+from ormlambda.sql.clause_info import ClauseInfo
+from ormlambda.common.interfaces.IQueryCommand import IQuery
+from ormlambda.sql.clause_info import ClauseInfoContext, IAggregate
 
+if tp.TYPE_CHECKING:
+    from ormlambda.sql.types import ColumnType
+    from ormlambda import Table
+    from ormlambda.sql.types import AliasType
 
-class Alias[T: tp.Type[Table], *Ts](DecompositionQueryBase[T, *Ts], ICustomAlias[T, *Ts]):
+
+class Alias[T: Table, TProp](ClauseInfo, IQuery):
     def __init__(
         self,
-        table: T,
-        query: tp.Callable[[T, *Ts], tp.Any],
-        *,
-        alias: bool = True,
-        alias_name: str | None = None,
-    ) -> None:
-        super().__init__(
-            table,
-            lambda_query=query,
-            alias=alias,
-            alias_name=alias_name,
-        )
+        element: IAggregate | ClauseInfo[T] | ColumnType[TProp],
+        alias_clause: tp.Optional[AliasType[ClauseInfo[T]]],
+    ):
+        if isinstance(element, Column):
+            context = ClauseInfoContext()
+            element = ClauseInfo(table=element.table, column=element, alias_clause=alias_clause)
+        else:
+            context = ClauseInfoContext(table_context=element.context._table_context, clause_context={})
+            element.context = context
+            element._alias_clause = alias_clause
 
-    def alias_children_resolver[Tclause: tp.Type[Table]](self, clause_info: ClauseInfo[Tclause]):
-        return self.alias_name
+        self._element = element
 
+    @tp.override
     @property
     def query(self) -> str:
-        assert len(self.all_clauses) == 1
-
-        return self.all_clauses[0].query
+        return self._element.query