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

ormlambda/__init__.py

@@ -1,3 +1,5 @@
+import ormlambda.env  # noqa: F401 Necesary to load all variables inside ormalambda.env
+
 # region enums
 from .common.enums import (
     JoinType as JoinType,

ormlambda/caster/__init__.py

@@ -1,3 +1,3 @@
 from .base_caster import BaseCaster  # noqa: F401
-from .caster import Caster, PLACEHOLDER  # noqa: F401
+from .caster import Caster  # noqa: F401
 from .interfaces import ICaster  # noqa: F401

ormlambda/caster/caster.py

@@ -1,24 +1,26 @@
 from __future__ import annotations
 
 
-from typing import Optional, Type, TYPE_CHECKING, Callable, overload
-
+from typing import ClassVar, Optional, Type, TYPE_CHECKING, Callable, overload, get_args
+from types import NoneType
+from ormlambda.caster.interfaces import ICaster
 from ormlambda.common.global_checker import GlobalChecker
 from ormlambda.sql.types import ColumnType
-from ormlambda.engine.template import RepositoryTemplateDict
+from ormlambda.caster import BaseCaster
+from ormlambda.sql.sqltypes import TypeEngine
+
 
 if TYPE_CHECKING:
     from ormlambda.caster import BaseCaster
-    from ormlambda.repository import IRepositoryBase
 
 
-PLACEHOLDER: str = "%s"
+class Caster(ICaster):
+    PLACEHOLDER: ClassVar[str] = "%s"
 
-
-class Caster:
-    def __init__(self, repository: IRepositoryBase):
-        self._repository: IRepositoryBase = repository
-        self._caster = RepositoryTemplateDict().get(repository).caster
+    @classmethod
+    def set_placeholder(cls, char: str) -> None:
+        cls.PLACEHOLDER = char
+        return None
 
     @overload
     def for_column[T, TProp](self, column: Callable[[T], TProp], instance: T) -> BaseCaster[TProp, Type[TProp]]: ...
@@ -36,7 +38,7 @@ class Caster:
             column_type = column.dtype
             value = instance[column]
 
-        return self._caster.cast(value, column_type)
+        return self.cast(value, column_type)
 
     @overload
     def for_value[TProp](self, value: TProp) -> BaseCaster[TProp, Type[TProp]]: ...
@@ -45,4 +47,19 @@ class Caster:
 
     def for_value[TProp, TType](self, value: TProp, value_type: Optional[TType] = None) -> BaseCaster[TProp, TType]:
         column_type = value_type if value_type else type(value)
-        return self._caster.cast(value, column_type)
+        return self.cast(value, column_type)
+
+    @classmethod
+    def cast[TProp, TType](cls, value: TProp, type_value: Optional[TypeEngine[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]
+
+        if isinstance(type_value, TypeEngine):
+            column_type = type_value.python_type
+        elif not type_value:
+            column_type = type(value)
+        else:
+            column_type = type_value
+        return cls.CASTER_SELECTOR()[column_type](value, column_type)

ormlambda/common/abstract_classes/clause_info_converter.py

@@ -17,21 +17,13 @@ class ClauseInfoConverter[T, TProp](tp.Protocol):
 class ConvertFromAnyType(ClauseInfoConverter[None, None]):
     @classmethod
     def convert(cls, data: tp.Any, alias_table: AliasType = "{table}", context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[None]]:
-        return [
-            ClauseInfo[None](
-                table=None,
-                column=data,
-                alias_table=alias_table,
-                alias_clause=kwargs.get("alias", None),
-                context=context,
-            )
-        ]
+        return [ClauseInfo[None](table=None, column=data, alias_table=alias_table, alias_clause=kwargs.get("alias", None), context=context, **kwargs)]
 
 
 class ConvertFromForeignKey[LT: Table, RT: Table](ClauseInfoConverter[RT, None]):
     @classmethod
     def convert(cls, data: ForeignKey[LT, RT], alias_table=None, context: ClauseContextType = None, **kwargs) -> list[ClauseInfo[RT]]:
-        return ConvertFromTable[RT].convert(data.tright, data.alias, context, **kwargs)
+        return ConvertFromTable[RT].convert(data.tright, data.get_alias(kwargs["dialect"]), context, **kwargs)
 
 
 class ConvertFromColumn[TProp](ClauseInfoConverter[None, TProp]):
@@ -44,9 +36,9 @@ class ConvertFromColumn[TProp](ClauseInfoConverter[None, TProp]):
             "alias_table": alias_table,
             "alias_clause": "{table}_{column}",
             "context": context,
-            **kwargs,
         }
-        clause_info = ClauseInfo[None](**attributes)
+        attributes.update(**kwargs)
+        clause_info = ClauseInfo(**attributes)
         return [clause_info]
 
 

ormlambda/common/abstract_classes/decomposition_query.py

@@ -27,6 +27,9 @@ type ValueType = tp.Union[
     tp.Type[ICustomAlias],
 ]
 
+if tp.TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
+
 
 class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
     @tp.overload
@@ -36,10 +39,20 @@ class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
     @tp.overload
     def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], alias_table: str, context: ClauseContextType = ...) -> None: ...
 
-    def __init__(self, tables: tuple[TableType[T]], columns: tuple[ColumnType], alias_table: str = "{table}", *, context: ClauseContextType = ClauseInfoContext(), **kwargs) -> None:
+    def __init__(
+        self,
+        tables: tuple[TableType[T]],
+        columns: tuple[ColumnType],
+        alias_table: str = "{table}",
+        *,
+        context: ClauseContextType = ClauseInfoContext(),
+        dialect: Dialect,
+        **kwargs,
+    ) -> None:
         self.kwargs = kwargs
         self._tables: tuple[TableType[T]] = tables if isinstance(tables, tp.Iterable) else (tables,)
 
+        self._dialect = dialect
         self._columns: tp.Callable[[T], tuple] = columns
         self._all_clauses: list[ClauseInfo | AggregateFunctionBase] = []
         self._context: ClauseContextType = context if context else ClauseInfoContext()
@@ -88,7 +101,9 @@ class DecompositionQueryBase[T: Table, *Ts](IDecompositionQuery[T, *Ts]):
             Table: ConvertFromTable[T],
         }
         classConverter = next((converter for obj, converter in VALUE_TYPE_MAPPED.items() if validation(data, obj)), ConvertFromAnyType)
-
+        self.kwargs.setdefault("dialect", self._dialect)
+        if "dialect" not in self.kwargs:
+            raise ValueError("You must specified 'dialect' variable")
         return classConverter.convert(data, alias_table=self._alias_table, context=self._context, **self.kwargs)
 
     def __add_clause[TTable: TableType](self, clauses: list[ClauseInfo[TTable]] | ClauseInfo[TTable]) -> None:

ormlambda/common/abstract_classes/non_query_base.py

@@ -1,22 +1,26 @@
 from __future__ import annotations
 from abc import abstractmethod
-from typing import Any, Optional, Type, override, TYPE_CHECKING
+from typing import Any, Optional, Type, TYPE_CHECKING
 
 from ormlambda.common.interfaces.INonQueryCommand import INonQueryCommand
 
 if TYPE_CHECKING:
     from ormlambda.repository import BaseRepository
+    from ormlambda.dialects import Dialect
     from ormlambda import Table
+    from ormlambda.engine import Engine
 
 
-class NonQueryBase[T: Type[Table], TRepo: BaseRepository](INonQueryCommand):
+class NonQueryBase[T: Type[Table], TRepo](INonQueryCommand):
     __slots__: tuple[str, ...] = ("_model", "_repository", "_values", "_query")
 
-    def __init__(self, model: T, repository: TRepo) -> None:
+    def __init__(self, model: T, repository: TRepo, **kwargs) -> None:
         self._model: T = model
-        self._repository: TRepo = repository
+        self._repository: BaseRepository[TRepo] = repository
         self._values: list[tuple[Any]] = []
         self._query: Optional[str] = None
+        self._dialect: Dialect = kwargs.get("dialect", None)
+        self._engine: Optional[Engine] = kwargs.get("engine", None)
 
     @property
     @abstractmethod
@@ -25,9 +29,7 @@ class NonQueryBase[T: Type[Table], TRepo: BaseRepository](INonQueryCommand):
     @abstractmethod
     def execute(self) -> None: ...
 
-    @property
-    @override
-    def query(self) -> str:
+    def query(self, dialect: Dialect, **kwargs) -> str:
         return self._query
 
     @property

ormlambda/common/abstract_classes/query_base.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from abc import abstractmethod
 from typing import TYPE_CHECKING
 
@@ -5,9 +6,10 @@ from ormlambda.common.interfaces import IQuery
 
 if TYPE_CHECKING:
     from ormlambda import Table
+    from ormlambda.dialects import Dialect
 
 
 class QueryBase[T: Table](IQuery):
     @property
     @abstractmethod
-    def query(self) -> str: ...
+    def query(self, dialect: Dialect, **kwargs) -> str: ...

ormlambda/common/errors/__init__.py

@@ -1,7 +1,12 @@
+from __future__ import annotations
 import inspect
 import typing as tp
 
 
+if tp.TYPE_CHECKING:
+    from ormlambda.sql.clause_info import ClauseInfo
+
+
 class UnmatchedLambdaParameterError(Exception):
     def __init__(self, expected_params: int, function: tp.Callable[..., tp.Any], *args: object) -> None:
         super().__init__(*args)
@@ -19,3 +24,27 @@ class NotKeysInIAggregateError(Exception):
 
     def __str__(self) -> str:
         return f"We cannot use placeholders in IAggregate class. You used {self._match_regex}"
+
+
+class AggregateFunctionError[T](Exception):
+    def __init__(self, clause: ClauseInfo[T], *args):
+        self.clause = clause
+        super().__init__(*args)
+
+    def __str__(self):
+        agg_methods = self.__get_all_aggregate_method(self.clause)
+        return f"You cannot use aggregation method like '{agg_methods}' to return model objects. Try specifying 'flavour' attribute as 'dict'."
+
+    def __get_all_aggregate_method(self, clauses: list[ClauseInfo]) -> str:
+        """
+        Get the class name of those classes that inherit from 'AggregateFunctionBase' class in order to create a better error message.
+        """
+        from ormlambda.sql.clause_info import AggregateFunctionBase
+
+        res: set[str] = set()
+        if not isinstance(clauses, tp.Iterable):
+            return clauses.__class__.__name__
+        for clause in clauses:
+            if isinstance(clause, AggregateFunctionBase):
+                res.add(clause.__class__.__name__)
+        return ", ".join(res)

ormlambda/common/interfaces/IQueryCommand.py

@@ -1,12 +1,16 @@
+from __future__ import annotations
 from abc import abstractmethod, ABC
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ormlambda.dialects import Dialect
 
 
 class IQuery(ABC):
     """Interface to queries that retrieve any element such as select, limit, offset, where, group by, etc..."""
 
-    @property
     @abstractmethod
-    def query(self) -> str: ...
+    def query(self, dialect: Dialect, **kwargs) -> str: ...
 
     def __repr__(self) -> str:
         return f"{IQuery.__name__}: {self.__class__.__name__}"

ormlambda/databases/__init__.py

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

ormlambda/databases/my_sql/__init__.py

@@ -1,4 +1,3 @@
 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/caster.py

@@ -1,18 +1,29 @@
 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 ormlambda.caster.caster import Caster
+
+
+from .types import (
+    StringCaster,
+    IntegerCaster,
+    FloatCaster,
+    PointCaster,
+    NoneTypeCaster,
+    DatetimeCaster,
+    BytesCaster,
+    IterableCaster,
+    BooleanCaster,
+    DecimalCaster,
+)
 
 from shapely import Point
 from types import NoneType
-from datetime import datetime
+from datetime import datetime, date
+from decimal import Decimal
+
 
+class MySQLCaster(Caster):
+    PLACEHOLDER = "%s"
 
-class MySQLCaster(ICaster):
     @classmethod
     def CASTER_SELECTOR(cls):
         return {
@@ -22,18 +33,11 @@ class MySQLCaster(ICaster):
             Point: PointCaster,
             NoneType: NoneTypeCaster,
             datetime: DatetimeCaster,
+            date: DatetimeCaster,
             bytes: BytesCaster,
             bytearray: BytesCaster,
             tuple: IterableCaster,
             list: IterableCaster,
+            bool: BooleanCaster,
+            Decimal: DecimalCaster,
         }
-
-    @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/types/__init__.py

@@ -6,3 +6,6 @@ from .none import NoneTypeCaster as NoneTypeCaster
 from .datetime import DatetimeCaster as DatetimeCaster
 from .bytes import BytesCaster as BytesCaster
 from .iterable import IterableCaster as IterableCaster
+from .boolean import BooleanCaster as BooleanCaster
+from .date import DateCaster as DateCaster
+from .decimal import DecimalCaster as DecimalCaster

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

@@ -0,0 +1,35 @@
+from typing import Optional
+from ormlambda.caster import BaseCaster, Caster
+
+
+class BooleanCaster[TType](BaseCaster[bool, TType]):
+    """
+    MySQL uses 0/1 for booleans stored in TINYINT
+    """
+
+    def __init__(self, value: bool, type_value: TType):
+        super().__init__(value, type_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: Optional[str] = None) -> str:
+        return Caster.PLACEHOLDER if value is None else 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
+    def to_database(self) -> Optional[int]:
+        return 1 if self.value else 0
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def from_database(self) -> Optional[bool]:
+        return bool(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def string_data(self) -> Optional[str]:
+        return str(bool(self.value))

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

@@ -1,19 +1,19 @@
 from typing import Optional
-from ormlambda.caster import BaseCaster, PLACEHOLDER
+from ormlambda.caster import BaseCaster, Caster
 
 
 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_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/caster/types/date.py

@@ -0,0 +1,34 @@
+from typing import Optional
+from ormlambda.caster import BaseCaster, Caster
+from datetime import datetime
+from .string import StringCaster
+
+
+class DateCaster[TType](BaseCaster[datetime, TType]):
+    def __init__(self, value: datetime, type_value: TType):
+        super().__init__(value, type_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: Optional[str] = None) -> str:
+        return Caster.PLACEHOLDER if value is None else 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
+    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")
+        return StringCaster(datetime_string, str).string_data

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

@@ -1,5 +1,5 @@
 from typing import Optional
-from ormlambda.caster import BaseCaster, PLACEHOLDER
+from ormlambda.caster import BaseCaster, Caster
 from datetime import datetime
 from .string import StringCaster
 
@@ -8,14 +8,14 @@ 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_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/caster/types/decimal.py

@@ -0,0 +1,32 @@
+from typing import Optional
+from ormlambda.caster import BaseCaster, Caster
+from decimal import Decimal
+
+
+class DecimalCaster[TType](BaseCaster[Decimal, TType]):
+    def __init__(self, value: Decimal, type_value: TType):
+        super().__init__(value, type_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: Optional[str] = None) -> str:
+        return Caster.PLACEHOLDER if value is None else 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
+    def to_database(self) -> Optional[Decimal]:
+        return Decimal(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def from_database(self) -> Optional[Decimal]:
+        return Decimal(self.value)
+
+    @property
+    @BaseCaster.return_value_if_exists
+    def string_data(self) -> Optional[str]:
+        return str(self.value)

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

@@ -1,19 +1,19 @@
 from typing import Optional
-from ormlambda.caster import BaseCaster, PLACEHOLDER
+from ormlambda.caster import BaseCaster, Caster
 
 
 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_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/caster/types/int.py

@@ -1,19 +1,19 @@
 from typing import Optional
-from ormlambda.caster import BaseCaster, PLACEHOLDER
+from ormlambda.caster import BaseCaster, Caster
 
 
 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_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/caster/types/iterable.py

@@ -1,19 +1,19 @@
 from typing import Optional
-from ormlambda.caster import BaseCaster, PLACEHOLDER
+from ormlambda.caster import BaseCaster, Caster
 
 
 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_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/caster/types/none.py

@@ -1,19 +1,20 @@
 from types import NoneType
-from ormlambda.caster import BaseCaster, PLACEHOLDER
+from typing import Optional
+from ormlambda.caster import BaseCaster, Caster
 
 
 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_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
 
     # TODOL: cheched if it's right
     @property

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

@@ -1,5 +1,5 @@
 from typing import Optional
-from ormlambda.caster import BaseCaster, PLACEHOLDER
+from ormlambda.caster import BaseCaster, Caster
 from shapely import Point
 import shapely.wkt as wkt
 from shapely import wkb
@@ -9,13 +9,13 @@ 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:
+    def wildcard_to_select(self, value: str = Caster.PLACEHOLDER) -> str:
         return f"ST_AsText({value})"
 
-    def wildcard_to_where(self, value: str = PLACEHOLDER) -> str:
+    def wildcard_to_where(self, value: str = Caster.PLACEHOLDER) -> str:
         return f"ST_AsText({value})"
 
-    def wildcard_to_insert(self, value: str = PLACEHOLDER) -> str:
+    def wildcard_to_insert(self, value: str = Caster.PLACEHOLDER) -> str:
         return f"ST_GeomFromText({value})"
 
     @property