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

ormlambda/__init__.py

@@ -24,3 +24,36 @@ from .model.base_model import (
 )  # COMMENT: to avoid relative import we need to import BaseModel after import Table,Column, ForeignKey, IRepositoryBase and Disassembler
 
 from .engine import create_engine, URL, make_url  # noqa: F401
+
+from .sql.sqltypes import (  # noqa: F401
+    JSON as JSON,
+    UUID as UUID,
+    NullType as NullType,
+    INTEGER as INTEGER,
+    INT as INT,
+    SMALLINTEGER as SMALLINTEGER,
+    BIGINTEGER as BIGINTEGER,
+    NUMERIC as NUMERIC,
+    FLOAT as FLOAT,
+    REAL as REAL,
+    DOUBLE as DOUBLE,
+    DECIMAL as DECIMAL,
+    STRING as STRING,
+    TEXT as TEXT,
+    UNICODE as UNICODE,
+    UNICODETEXT as UNICODETEXT,
+    CHAR as CHAR,
+    NCHAR as NCHAR,
+    BLOB as BLOB,
+    VARCHAR as VARCHAR,
+    NVARCHAR as NVARCHAR,
+    DATE as DATE,
+    TIME as TIME,
+    DATETIME as DATETIME,
+    TIMESTAMP as TIMESTAMP,
+    BOOLEAN as BOOLEAN,
+    LARGEBINARY as LARGEBINARY,
+    VARBINARY as VARBINARY,
+    ENUM as ENUM,
+    POINT as POINT,
+)

ormlambda/dialects/mysql/__init__.py

@@ -1,8 +1,84 @@
 from . import base
 from . import mysqlconnector
 
-# default dialect
-base.dialect = dialect = mysqlconnector.dialect
+from .base import BIGINT
+from .base import BINARY
+from .base import BIT
+from .base import BLOB
+from .base import BOOLEAN
+from .base import CHAR
+from .base import DATE
+from .base import DATETIME
+from .base import DECIMAL
+from .base import DOUBLE
+from .base import FLOAT
+from .base import INTEGER
+from .base import LONGBLOB
+from .base import LONGTEXT
+from .base import MEDIUMBLOB
+from .base import MEDIUMINT
+from .base import MEDIUMTEXT
+from .base import NCHAR
+from .base import NUMERIC
+from .base import NVARCHAR
+from .base import REAL
+from .base import SMALLINT
+from .base import TEXT
+from .base import TIME
+from .base import TIMESTAMP
+from .base import TINYBLOB
+from .base import TINYINT
+from .base import TINYTEXT
+from .base import VARBINARY
+from .base import VARCHAR
+from .base import YEAR
+
+
 
+__all__ = (
+    "BIGINT",
+    "BINARY",
+    "BIT",
+    "BLOB",
+    "BOOLEAN",
+    "CHAR",
+    "DATE",
+    "DATETIME",
+    "DECIMAL",
+    "DOUBLE",
+    "ENUM",
+    "FLOAT",
+    "INET4",
+    "INET6",
+    "INTEGER",
+    "INTEGER",
+    "JSON",
+    "LONGBLOB",
+    "LONGTEXT",
+    "MEDIUMBLOB",
+    "MEDIUMINT",
+    "MEDIUMTEXT",
+    "NCHAR",
+    "NVARCHAR",
+    "NUMERIC",
+    "SET",
+    "SMALLINT",
+    "REAL",
+    "TEXT",
+    "TIME",
+    "TIMESTAMP",
+    "TINYBLOB",
+    "TINYINT",
+    "TINYTEXT",
+    "VARBINARY",
+    "VARCHAR",
+    "YEAR",
+    "dialect",
+    "insert",
+    "Insert",
+    "match",
+)
 
-from .types import *  # noqa: F403
+
+# default dialect
+base.dialect = dialect = mysqlconnector.dialect

ormlambda/dialects/mysql/base.py

@@ -10,7 +10,10 @@ if TYPE_CHECKING:
 
 from .types import (
     _NumericType,
+    _NumericCommonType,
     _StringType,
+    VARCHAR,
+    CHAR,
     NUMERIC,
     DECIMAL,
     DOUBLE,
@@ -36,7 +39,16 @@ from .types import (
     MEDIUMBLOB,
     LONGBLOB,
 )
-from ormlambda.sql.sqltypes import BLOB
+from ormlambda.sql.sqltypes import (
+    LARGEBINARY,
+    BLOB,
+    BOOLEAN,
+    DATE,
+    UUID,
+    VARBINARY,
+    BINARY,
+)
+
 
 from ormlambda.databases.my_sql import MySQLRepository, MySQLCaster
 
@@ -73,7 +85,7 @@ class MySQLCompiler(compiler.SQLCompiler):
     """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)}"
+        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)
@@ -110,7 +122,7 @@ class MySQLCompiler(compiler.SQLCompiler):
         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])}")
+            string_columns.append(f"{clause.query(self.dialect, **kw)} {str(order._order_type[index])}")
 
         return f"{order.FUNCTION_NAME()} {', '.join(string_columns)}"
 
@@ -122,7 +134,7 @@ class MySQLCompiler(compiler.SQLCompiler):
 
 class MySQLDDLCompiler(compiler.DDLCompiler):
     def get_column_specification(self, column: Column, **kwargs):
-        colspec = column.column_name + " " + self.dialect.type_compiler_instance.process(column.dtype)
+        colspec = column.column_name + " " + self.dialect.type_compiler_instance.process(column.dbtype)
         default = self.get_column_default_string(column)
         if default is not None:
             colspec += " DEFAULT " + default
@@ -164,7 +176,7 @@ class MySQLTypeCompiler(compiler.GenericTypeCompiler):
             return getattr(type_, name, defaults.get(name))
 
         if attr("charset"):
-            charset = f"CHARACTER SET {attr("charset")}"
+            charset = f"CHARACTER SET {attr('charset')}"
         elif attr("ascii"):
             charset = "ASCII"
         elif attr("unicode"):
@@ -184,183 +196,238 @@ class MySQLTypeCompiler(compiler.GenericTypeCompiler):
             return " ".join([c for c in ("NATIONAL", spec, collation) if c is not None])
         return " ".join([c for c in (spec, charset, collation) if c is not None])
 
-    def visit_INTEGER(self, type_: INTEGER, **kw):
-        if self.mysql_type(type_) and type_.display_width is not None:
+    def _mysql_type(self, type_, **kw):
+        return isinstance(type, _StringType | _NumericCommonType)
+
+    def visit_NUMERIC(self, type_: NUMERIC, **kw):
+        if type_.precision is None:
+            return self._extend_numeric(type_, "NUMERIC")
+        elif type_.scale is None:
             return self._extend_numeric(
                 type_,
-                f"INTEGER(%({type_.display_width})s)",
+                f"NUMERIC({type_.precision})",
             )
         else:
-            return self._extend_numeric(type_, "INTEGER")
-
-    def visit_VARCHAR(self, type_, **kw):
-        if type_.length is None:
-            raise ValueError("VARCHAR requires a length on dialect %s" % self.dialect.name)
-        return self._extend_string(type_, {}, "VARCHAR(%d)" % type_.length)
-
-    def visit_CHAR(self, type_, **kw):
-        if type_.length is not None:
-            return self._extend_string(type_, {}, "CHAR(%(length)s)" % {"length": type_.length})
-        else:
-            return self._extend_string(type_, {}, "CHAR")
-
-    def visit_NUMERIC(self, type_: NUMERIC, **kw):
-        return "NUMERIC"
+            return self._extend_numeric(
+                type_,
+                f"NUMERIC({type_.precision}, {type_.scale})",
+            )
 
     def visit_DECIMAL(self, type_: DECIMAL, **kw):
-        return "DECIMAL"
+        if type_.precision is None:
+            return self._extend_numeric(type_, "DECIMAL")
+        elif type_.scale is None:
+            return self._extend_numeric(
+                type_,
+                f"DECIMAL({type_.precision})",
+            )
+        else:
+            return self._extend_numeric(
+                type_,
+                f"DECIMAL({type_.precision}, {type_.scale})",
+            )
 
     def visit_DOUBLE(self, type_: DOUBLE, **kw):
-        return "DOUBLE"
+        if type_.precision is not None and type_.scale is not None:
+            return self._extend_numeric(
+                type_,
+                f"DOUBLE({type_.precision}, {type_.scale})",
+            )
+        else:
+            return self._extend_numeric(type_, "DOUBLE")
 
     def visit_REAL(self, type_: REAL, **kw):
-        return "REAL"
+        if type_.precision is not None and type_.scale is not None:
+            return self._extend_numeric(
+                type_,
+                f"REAL({type_.precision}, {type_.scale})",
+            )
+        else:
+            return self._extend_numeric(type_, "REAL")
 
     def visit_FLOAT(self, type_: FLOAT, **kw):
-        return "FLOAT"
+        if self._mysql_type(type_) and type_.scale is not None and type_.precision is not None:
+            return self._extend_numeric(type_, f"FLOAT({type_.precision}, {type_.scale})")
+        elif type_.precision is not None:
+            return self._extend_numeric(type_, f"FLOAT({type_.precision})")
+        else:
+            return self._extend_numeric(type_, "FLOAT")
+
+    def visit_INTEGER(self, type_: INTEGER, **kw):
+        if self._mysql_type(type_) and type_.display_width is not None:
+            return self._extend_numeric(
+                type_,
+                f"INTEGER({type_.display_width})",
+            )
+        else:
+            return self._extend_numeric(type_, "INTEGER")
 
     def visit_BIGINT(self, type_: BIGINT, **kw):
-        return "BIGINT"
+        if self._mysql_type(type_) and type_.display_width is not None:
+            return self._extend_numeric(
+                type_,
+                f"BIGINT({type_.display_width})",
+            )
+        else:
+            return self._extend_numeric(type_, "BIGINT")
 
     def visit_MEDIUMINT(self, type_: MEDIUMINT, **kw):
-        return "MEDIUMINT"
+        if self._mysql_type(type_) and type_.display_width is not None:
+            return self._extend_numeric(
+                type_,
+                f"MEDIUMINT({type_.display_width})",
+            )
+        else:
+            return self._extend_numeric(type_, "MEDIUMINT")
 
     def visit_TINYINT(self, type_: TINYINT, **kw):
-        return "TINYINT"
+        if self._mysql_type(type_) and type_.display_width is not None:
+            return self._extend_numeric(type_, f"TINYINT({type_.display_width})")
+        else:
+            return self._extend_numeric(type_, "TINYINT")
 
     def visit_SMALLINT(self, type_: SMALLINT, **kw):
-        return "SMALLINT"
+        if self._mysql_type(type_) and type_.display_width is not None:
+            return self._extend_numeric(
+                type_,
+                f"SMALLINT({type_.display_width})",
+            )
+        else:
+            return self._extend_numeric(type_, "SMALLINT")
 
     def visit_BIT(self, type_: BIT, **kw):
-        return "BIT"
+        if type_.length is not None:
+            return f"BIT({type_.length})"
+        else:
+            return "BIT"
+
+    def visit_DATETIME(self, type_: DATETIME, **kw):
+        if getattr(type_, "fsp", None):
+            return f"DATETIME({type_.fsp})"
+        else:
+            return "DATETIME"
+
+    def visit_DATE(self, type_: DATE, **kw):
+        return "DATE"
 
     def visit_TIME(self, type_: TIME, **kw):
-        return "TIME"
+        if getattr(type_, "fsp", None):
+            return f"TIME({type_.fsp})"
+        else:
+            return "TIME"
 
     def visit_TIMESTAMP(self, type_: TIMESTAMP, **kw):
-        return "TIMESTAMP"
-
-    def visit_DATETIME(self, type_: DATETIME, **kw):
-        return "DATETIME"
+        if getattr(type_, "fsp", None):
+            return f"TIMESTAMP({type_.fsp})"
+        else:
+            return "TIMESTAMP"
 
     def visit_YEAR(self, type_: YEAR, **kw):
-        return "YEAR"
+        if type_.display_width is None:
+            return "YEAR"
+        else:
+            return f"YEAR({type_.display_width})"
 
     def visit_TEXT(self, type_: TEXT, **kw):
         if type_.length is not None:
             return self._extend_string(type_, {}, f"TEXT({type_.length})")
-        return self._extend_string(type_, {}, "TEXT")
+        else:
+            return self._extend_string(type_, {}, "TEXT")
 
     def visit_TINYTEXT(self, type_: TINYTEXT, **kw):
-        return "TINYTEXT"
+        return self._extend_string(type_, {}, "TINYTEXT")
 
     def visit_MEDIUMTEXT(self, type_: MEDIUMTEXT, **kw):
-        return "MEDIUMTEXT"
+        return self._extend_string(type_, {}, "MEDIUMTEXT")
 
     def visit_LONGTEXT(self, type_: LONGTEXT, **kw):
-        return "LONGTEXT"
-
-    def visit_NVARCHAR(self, type_: NVARCHAR, **kw):
-        return "NVARCHAR"
-
-    def visit_NCHAR(self, type_: NCHAR, **kw):
-        return "NCHAR"
-
-    def visit_TINYBLOB(self, type_: TINYBLOB, **kw):
-        return "TINYBLOB"
-
-    def visit_BLOB(self, type_: BLOB, **kw) -> str:
-        blob = "BLOB"
-        blob += f"({type_.length})" if type_.length is not None else ""
-        return blob
-
-    def visit_MEDIUMBLOB(self, type_: MEDIUMBLOB, **kw):
-        return "MEDIUMBLOB"
-
-    def visit_LONGBLOB(self, type_: LONGBLOB, **kw):
-        return "LONGBLOB"
-
-    # region visit lowercase
-
-    def visit_integer(self, type_: INTEGER, **kw):
-        return self.visit_INTEGER(type_, **kw)
-
-    def visit_varchar(self, type_, **kw):
-        return self.visit_VARCHAR(type_, **kw)
-
-    def visit_char(self, type_, **kw):
-        return self.visit_CHAR(type_, **kw)
-
-    def visit_numeric(self, type_: NUMERIC, **kw):
-        return self.visit_NUMERIC(type_, **kw)
-
-    def visit_decimal(self, type_: DECIMAL, **kw):
-        return self.visit_DECIMAL(type_, **kw)
-
-    def visit_double(self, type_: DOUBLE, **kw):
-        return self.visit_DOUBLE(type_, **kw)
+        return self._extend_string(type_, {}, "LONGTEXT")
 
-    def visit_real(self, type_: REAL, **kw):
-        return self.visit_REAL(type_, **kw)
-
-    def visit_float(self, type_: FLOAT, **kw):
-        return self.visit_FLOAT(type_, **kw)
-
-    def visit_bigint(self, type_: BIGINT, **kw):
-        return self.visit_BIGINT(type_, **kw)
-
-    def visit_mediumint(self, type_: MEDIUMINT, **kw):
-        return self.visit_MEDIUMINT(type_, **kw)
-
-    def visit_tinyint(self, type_: TINYINT, **kw):
-        return self.visit_TINYINT(type_, **kw)
+    def visit_VARCHAR(self, type_: VARCHAR, **kw):
+        if type_.length is not None:
+            return self._extend_string(type_, {}, f"VARCHAR({type_.length})")
+        else:
+            raise ValueError(f"VARCHAR requires a length on dialect {self.dialect.name}")
 
-    def visit_smallint(self, type_: SMALLINT, **kw):
-        return self.visit_SMALLINT(type_, **kw)
+    def visit_CHAR(self, type_: CHAR, **kw):
+        if type_.length is not None:
+            return self._extend_string(type_, {}, f"CHAR({type_.length})")
+        else:
+            return self._extend_string(type_, {}, "CHAR")
 
-    def visit_bit(self, type_: BIT, **kw):
-        return self.visit_BIT(type_, **kw)
+    def visit_NVARCHAR(self, type_: NVARCHAR, **kw):
+        # We'll actually generate the equiv. "NATIONAL VARCHAR" instead
+        # of "NVARCHAR".
+        if type_.length is not None:
+            return self._extend_string(
+                type_,
+                {"national": True},
+                f"VARCHAR({type_.length})",
+            )
+        else:
+            raise ValueError(f"NVARCHAR requires a length on dialect {self.dialect.name}")
 
-    def visit_time(self, type_: TIME, **kw):
-        return self.visit_TIME(type_, **kw)
+    def visit_NCHAR(self, type_: NCHAR, **kw):
+        # We'll actually generate the equiv.
+        # "NATIONAL CHAR" instead of "NCHAR".
+        if type_.length is not None:
+            return self._extend_string(
+                type_,
+                {"national": True},
+                f"CHAR({type_.length})",
+            )
+        else:
+            return self._extend_string(type_, {"national": True}, "CHAR")
 
-    def visit_timestamp(self, type_: TIMESTAMP, **kw):
-        return self.visit_TIMESTAMP(type_, **kw)
+    def visit_UUID(self, type_: UUID, **kw):
+        return "UUID"
 
-    def visit_datetime(self, type_: DATETIME, **kw):
-        return self.visit_DATETIME(type_, **kw)
+    def visit_VARBINARY(self, type_: VARBINARY, **kw):
+        return f"VARBINARY({type_.length})"
 
-    def visit_year(self, type_: YEAR, **kw):
-        return self.visit_YEAR(type_, **kw)
+    def visit_JSON(self, type_, **kw):
+        return "JSON"
 
-    def visit_text(self, type_: TEXT, **kw):
-        return self.visit_TEXT(type_, **kw)
+    def visit_large_binary(self, type_: LARGEBINARY, **kw):
+        return self.visit_BLOB(type_)
 
-    def visit_tinytext(self, type_: TINYTEXT, **kw):
-        return self.visit_TINYTEXT(type_, **kw)
+    def visit_enum(self, type_, **kw):
+        if not type_.native_enum:
+            return super().visit_enum(type_)
+        else:
+            return self.visit_ENUM(type_, type_.enums)
 
-    def visit_mediumtext(self, type_: MEDIUMTEXT, **kw):
-        return self.visit_MEDIUMTEXT(type_, **kw)
+    def visit_BLOB(self, type_: BLOB, **kw):
+        if type_.length is not None:
+            return f"BLOB({type_.length})"
+        else:
+            return "BLOB"
 
-    def visit_longtext(self, type_: LONGTEXT, **kw):
-        return self.visit_LONGTEXT(type_, **kw)
+    def visit_TINYBLOB(self, type_: TINYBLOB, **kw):
+        return "TINYBLOB"
 
-    def visit_nvarchar(self, type_: NVARCHAR, **kw):
-        return self.visit_NVARCHAR(type_, **kw)
+    def visit_MEDIUMBLOB(self, type_: MEDIUMBLOB, **kw):
+        return "MEDIUMBLOB"
 
-    def visit_nchar(self, type_: NCHAR, **kw):
-        return self.visit_NCHAR(type_, **kw)
+    def visit_LONGBLOB(self, type_: LONGBLOB, **kw):
+        return "LONGBLOB"
 
-    def visit_tinyblob(self, type_: TINYBLOB, **kw):
-        return self.visit_TINYBLOB(type_, **kw)
+    def _visit_enumerated_values(self, name, type_, enumerated_values):
+        quoted_enums = []
+        for e in enumerated_values:
+            if self.dialect.identifier_preparer._double_percents:
+                e = e.replace("%", "%%")
+            quoted_enums.append(f"'{e.replace("'", "''")}'")
+        return self._extend_string(type_, {}, f"{name}({','.join(quoted_enums)})")
 
-    def visit_mediumblob(self, type_: MEDIUMBLOB, **kw):
-        return self.visit_MEDIUMBLOB(type_, **kw)
+    def visit_ENUM(self, type_, **kw):
+        return self._visit_enumerated_values("ENUM", type_, type_.enums)
 
-    def visit_longblob(self, type_: LONGBLOB, **kw):
-        return self.visit_LONGBLOB(type_, **kw)
+    def visit_SET(self, type_, **kw):
+        return self._visit_enumerated_values("SET", type_, type_.values)
 
-    # endregion
+    def visit_BOOLEAN(self, type_: BOOLEAN, **kw):
+        return "BOOL"
 
 
 class MySQLDialect(default.DefaultDialect):

ormlambda/dialects/mysql/types.py

@@ -32,7 +32,7 @@ class _NumericType(_NumericCommonType, sqltypes.Numeric): ...
 class _FloatType(_NumericCommonType, sqltypes.Float):
     def __init__(self, precision=None, scale=None, asdecimal=True, **kw):
         if isinstance(self, (REAL, DOUBLE)) and ((precision is None and scale is not None) or (precision is not None and scale is None)):
-            raise AttributeError("You must specify both precision and scale or omit " "both altogether.")
+            raise AttributeError("You must specify both precision and scale or omit both altogether.")
         super().__init__(precision=precision, asdecimal=asdecimal, **kw)
         self.scale = scale
 
@@ -42,6 +42,9 @@ class _IntegerType(_NumericCommonType, sqltypes.Integer):
         self.display_width = display_width
         super().__init__(**kw)
 
+    def __repr__(self):
+        return f"{type(self).__name__}({self.display_width})"
+
 
 class _StringType(sqltypes.String):
     """Base for MySQL string types."""

ormlambda/sql/clause_info/clause_info.py

@@ -9,6 +9,7 @@ from ormlambda.sql.types import (
     TableType,
     ColumnType,
     AliasType,
+    TypeEngine,
 )
 from .interface import IClauseInfo
 from ormlambda.sql import ForeignKey
@@ -166,6 +167,18 @@ class ClauseInfo[T: Table](IClauseInfo[T]):
             return self._column
         return type(self._column)
 
+    @property
+    def dbtype(self)->tp.Optional[TypeEngine]:
+        if self._dtype is not None:
+            return self._dtype
+
+        if isinstance(self._column, Column):
+            return self._column.dbtype
+
+        if isinstance(self._column, type):
+            return self._column
+        return type(self._column)
+
     def query(self, dialect: Dialect, **kwargs) -> str:
         return self._create_query(dialect, **kwargs)
 

ormlambda/sql/column/column.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 import abc
-from typing import Annotated, Any, Iterable, Type, Optional, TYPE_CHECKING, get_type_hints, overload, get_origin, get_args
+from typing import Annotated, Any, ClassVar, Iterable, Type, Optional, TYPE_CHECKING, get_type_hints, overload, get_origin, get_args
 from ormlambda.sql.types import TableType, ComparerType, ColumnType
 from ormlambda import ConditionType
+from ormlambda.sql.type_api import TypeEngine
 
 if TYPE_CHECKING:
     import re
     from ormlambda import Table
     from ormlambda.sql.comparer import Comparer, Regex, Like
-    from ormlambda.sql.type_api import TypeEngine
 
 
 from ormlambda.types import (
@@ -24,10 +24,13 @@ from ormlambda.types import (
 
 
 class Column[TProp]:
-    PRIVATE_CHAR: str = "_"
+    PRIVATE_CHAR: ClassVar[str] = "_"
+
+    _dbtype: Optional[TypeEngine]
 
     __slots__ = (
-        "dtype",
+        "_dtype",
+        "_dbtype",
         "column_name",
         "table",
         "is_primary_key",
@@ -111,7 +114,8 @@ class Column[TProp]:
 
     def __set__(self, obj, value):
         if self._check and value is not None:
-            if not isinstance(value, self.dtype):
+            type_ = self.dtype if not isinstance(self.dtype, TypeEngine) else self.dtype.python_type
+            if not isinstance(value, type_):
                 raise ValueError(f"The '{self.column_name}' Column from '{self.table.__table_name__}' table expected '{str(self.dtype)}' type. You passed '{type(value).__name__}' type")
         setattr(obj, self.__private_name, value)
 
@@ -132,8 +136,6 @@ class Column[TProp]:
     def _fill_from_annotations[T: Table](self, obj: Type[T], name: str) -> None:
         """Read the metada when using Annotated typing class, and set the attributes accordingly"""
 
-        from ormlambda.sql.type_api import TypeEngine
-
         annotations = get_type_hints(obj, include_extras=True)
         if name in annotations:
             annotation = annotations[name]
@@ -163,6 +165,23 @@ class Column[TProp]:
                         self.is_not_null = True
         return None
 
+    @property
+    def dtype(self) -> Type[TProp]:
+        return self._dtype
+
+    @dtype.setter
+    def dtype(self, value: Type[TProp] | TypeEngine) -> None:
+        if isinstance(value, TypeEngine):
+            self._dtype = value.python_type
+            self._dbtype = value
+        else:
+            self._dtype = value
+            self._dbtype = None
+
+    @property
+    def dbtype(self) -> TypeEngine[TProp]:
+        return self._dbtype if self._dbtype else self.dtype
+
     @abc.abstractmethod
     def __comparer_creator(self, other: ColumnType, compare: ComparerType) -> Comparer:
         from ormlambda.sql.comparer import Comparer

ormlambda/sql/sqltypes.py

@@ -10,6 +10,7 @@ import ormlambda.util as util
 from uuid import UUID as _python_UUID
 from shapely import Point as _python_Point
 
+
 class _NoArg(enum.Enum):
     NO_ARG = 0
 
@@ -391,7 +392,7 @@ class Enum(String, TypeEngine[EnumType]):
             enum_args = get_args(pt)
             bad_args = [arg for arg in enum_args if not isinstance(arg, str)]
             if bad_args:
-                raise ValueError(f"Can't create string-based Enum datatype from non-string " f"values: {', '.join(repr(x) for x in bad_args)}.  Please " f"provide an explicit Enum datatype for this Python type")
+                raise ValueError(f"Can't create string-based Enum datatype from non-string values: {', '.join(repr(x) for x in bad_args)}.  Please provide an explicit Enum datatype for this Python type")
             native_enum = False
             return enum_args, native_enum
 
@@ -407,7 +408,7 @@ class Enum(String, TypeEngine[EnumType]):
         elif util.is_pep695(python_type):
             value = python_type.__value__
             if not util.is_literal(value):
-                raise ValueError(f"Can't associate TypeAliasType '{python_type}' to an " "Enum since it's not a direct alias of a Literal. Only " "aliases in this form `type my_alias = Literal['a', " "'b']` are supported when generating Enums.")
+                raise ValueError(f"Can't associate TypeAliasType '{python_type}' to an Enum since it's not a direct alias of a Literal. Only aliases in this form `type my_alias = Literal['a', 'b']` are supported when generating Enums.")
             enum_args, native_enum = process_literal(value)
 
         elif isinstance(python_type, type) and issubclass(python_type, enum.Enum):
@@ -439,13 +440,15 @@ class Enum(String, TypeEngine[EnumType]):
 
         self._valid_lookup.update([(value, self._valid_lookup[self._object_lookup[value]]) for value in values])
 
+
 class Point(TypeEngine[_python_Point]):
-    __visit_name__ = 'point'
+    __visit_name__ = "point"
 
     @property
-    def python_type(self)->Type[_python_Point]:
+    def python_type(self) -> Type[_python_Point]:
         return _python_Point
-    
+
+
 class JSON(TypeEngine[Any]):
     """JSON data type."""
 
@@ -558,6 +561,12 @@ class BLOB(LargeBinary):
     __visit_name__ = "BLOB"
 
 
+class BINARY(_Binary):
+    """The SQL BINARY type."""
+
+    __visit_name__ = "BINARY"
+
+
 class VARCHAR(String):
     __visit_name__ = "VARCHAR"
 
@@ -597,6 +606,7 @@ class VARBINARY(Varbinary):
 class ENUM(Enum):
     __visit_name__ = "ENUM"
 
+
 class POINT(Point):
     __visit_name__ = "POINT"
 
@@ -623,13 +633,15 @@ _type_dicc: dict[Any, TypeEngine[Any]] = {
     float: Float(),
     NoneType: NULLTYPE,
     dt.datetime: Datetime(timezone=False),
+    dt.date: DATE(),
     bytes: _BINARY,
     bytearray: _BINARY,
     bool: Boolean(),
     enum.Enum: _ENUM,
     Literal: _ENUM,
     _python_UUID: UUID(),
-    _python_Point: POINT()
+    _python_Point: POINT(),
+    decimal.Decimal: DECIMAL(),
 }
 # enderegion
 

ormlambda/sql/type_api.py

@@ -33,3 +33,6 @@ class TypeEngine[T: Any](Element, abc.ABC):
         if _coerced_type is NULLTYPE:
             return self
         return _coerced_type
+
+    def __repr__(self):
+        return f"{TypeEngine.__name__}: {super().__repr__()}"

ormlambda/sql/visitors.py

@@ -72,3 +72,6 @@ class Element:
                 # return visitor.visit_unsupported_compilation(self, err, **kw)  # type: ignore  # noqa: E501
 
         cls._compiler_dispatch = _compiler_dispatch
+
+    def __repr__(self):
+        return f"{Element.__name__}: {self.__visit_name__}"

{ormlambda-3.34.1.dist-info → ormlambda-3.34.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ormlambda
-Version: 3.34.1
+Version: 3.34.6
 Summary: ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions
 Author: p-hzamora
 Author-email: p.hzamora@icloud.com

{ormlambda-3.34.1.dist-info → ormlambda-3.34.6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ormlambda/__init__.py,sha256=0s-uDYwzCsRAdN1z_dfzi6rb-9EiR3wcbSgQNJHxlyE,772
+ormlambda/__init__.py,sha256=uH9p7xjLHjQ8Dii3h6HWzWpB6pyKKpBvzAQgJ5klp0M,1505
 ormlambda/caster/__init__.py,sha256=lXzW6TJwgtyFTaBhKBETyGIxEje005S3SPg7PXnYEVQ,137
 ormlambda/caster/base_caster.py,sha256=c3vCGoKDyJ39kfUiS7sNKhKdjBRYSK1Ie88lwDIXqgE,1774
 ormlambda/caster/caster.py,sha256=2iilDARnNGGh-NVJKXr7nhxjoaQOLJGk3RnGoSzHpOY,2453
@@ -60,10 +60,10 @@ ormlambda/dialects/default/__init__.py,sha256=N1B0LKEDu7r2-mTF9mBA4ReyhYeDuJDnbQ
 ormlambda/dialects/default/base.py,sha256=rmK-nV5luN2lphSgisM8TBy3s4JXVgvZa79ATHeVOuU,1088
 ormlambda/dialects/interface/__init__.py,sha256=IbB5o6ae7XNVVfNt4uqZRZcVK9HHG6eLLK_E0J99kwY,43
 ormlambda/dialects/interface/dialect.py,sha256=z47GXCi-uJ6Oq7Zm64OHM0q61T3xWCss-uGdcuuXng0,2810
-ormlambda/dialects/mysql/__init__.py,sha256=y4gh32agzxxpjuC6x3oKEuCJYBwMYYuvJ-xxBS1rbv4,152
-ormlambda/dialects/mysql/base.py,sha256=ocDJprw5PFhZ9vsrrUJdBoqjwRwa3V163wK1p7j-gpc,11688
+ormlambda/dialects/mysql/__init__.py,sha256=1yAEM2MDcp56eSv1MrbtuDVQ5d_EzQ0S7ztSXKVS-eo,1511
+ormlambda/dialects/mysql/base.py,sha256=drHxKpFVVJPWy82rWSD2rFKvQ-GN8imoDmp3_ou4hcw,14535
 ormlambda/dialects/mysql/mysqlconnector.py,sha256=DOjK7U7LOhjuVQJULzAV8xaRGX0OlBU8APUeRiTcbDY,1378
-ormlambda/dialects/mysql/types.py,sha256=lOhdi442saxQJlQ_jgChBETE0fFMGTQLWN0a76R4fkc,23453
+ormlambda/dialects/mysql/types.py,sha256=ZQ75KyUwmNAt48F48CeIiMHgQjO0JeDXrksrrss2ILg,23537
 ormlambda/dialects/sqlite/__init__.py,sha256=2EMmxD7ORtGoD18GJ_9aC_tPutAq9ormMZJmaJ5nkYA,103
 ormlambda/dialects/sqlite/base.py,sha256=24LSB461yQDEnXa-TsQt_srJmBCAR6M6419pa40CL_4,1503
 ormlambda/dialects/sqlite/pysqlite.py,sha256=dZY0NV2IvSTk3DNEDyncstmIABKj3M2xfmhf2dc2zQs,680
@@ -85,7 +85,7 @@ ormlambda/repository/response.py,sha256=TBmWUGGoZChjXVhZXU3F84eUUA1rf7VPeNi92Ae8
 ormlambda/sql/__init__.py,sha256=0CWQzfxhTRWXozoRsg460o_ZwjW9w4uyL5jQUcD4eHg,121
 ormlambda/sql/clause_info/__init__.py,sha256=wOr8M0ZW7fJ-OGHok9eExh7fVP6kiwqGckEsKdE0U7A,255
 ormlambda/sql/clause_info/aggregate_function_base.py,sha256=FCTrXhDvO_XDVBXZK5AiUHonDENHT_MFxW6kn2_--6E,3541
-ormlambda/sql/clause_info/clause_info.py,sha256=ypiBjvuij4iKdMAkTPy7jlCa7hZIEi11agsaVCoHtKM,12674
+ormlambda/sql/clause_info/clause_info.py,sha256=OdqAwJgrB66Ypwh_PLFHnkZQk4gHPXXrsn-sEXpmHxo,13014
 ormlambda/sql/clause_info/clause_info_context.py,sha256=Y32p3x4mqcdNHbAowrKaN_ldnGn7zvaP1UdAkWWryhM,2852
 ormlambda/sql/clause_info/interface/IAggregate.py,sha256=P-QPaTMAMHVR5M9-ClmL8wsj0uNGG5xpxjuAwWnzKxA,216
 ormlambda/sql/clause_info/interface/IClauseInfo.py,sha256=Gnr6vArgimCt0oJqW-_q2_5jMi8EDBW1wZ8rEF2uzTk,921
@@ -114,7 +114,7 @@ ormlambda/sql/clauses/update.py,sha256=s4Vl_CmZzUYvdP2ThrTDz2ps_nU3_uwROQNICD06q
 ormlambda/sql/clauses/upsert.py,sha256=1MlHSzIVXSnCnXx_0HqX_-JT1FAxaIKHImrv-OKjnWU,2250
 ormlambda/sql/clauses/where.py,sha256=Db1IpXnbqAwzZpaThFDSxkrCNLsop__aJ43cDtcZ2Sk,2129
 ormlambda/sql/column/__init__.py,sha256=MwBJznOoeNE7tK9oppVtC3784XPkKo0yq9VLlh2lWUY,41
-ormlambda/sql/column/column.py,sha256=onneRMZJJd85sFkJZhgfcLTCChC-vHPcS7oukt-eSUY,7380
+ormlambda/sql/column/column.py,sha256=kDmLn5yxpYqPy98FyohHiHtHKDgF3LiERnfQYAnbNmE,7966
 ormlambda/sql/comparer.py,sha256=_KQ6gYe0eUg5aOL1i70mV8a1Qa1jI5UQr-0VfAMgVzk,5482
 ormlambda/sql/compiler.py,sha256=dSmF8RYQECPweKZI_TB9stDkLXTJy9FYvAQMNSCY8AY,12967
 ormlambda/sql/ddl.py,sha256=WhVoG_zlTT9DVZlnokHB8B1SC4ZXQSrXTQJ6vlnlpEY,1644
@@ -126,14 +126,14 @@ ormlambda/sql/functions/max.py,sha256=wXNhFmOlMyD1sKcaBO9asQeXcfY0OvMQPkrlARVXgd
 ormlambda/sql/functions/min.py,sha256=MTRGXgwzbLgKk9PJpn6JGK1TU91hZe_VsTszngLOh7Q,1570
 ormlambda/sql/functions/sum.py,sha256=_TN8SitDDBVD6VlsHZH3RpmiE5hkFrGGgC3tuEctKjk,1614
 ormlambda/sql/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ormlambda/sql/sqltypes.py,sha256=-YyzA-gPTnARoK29bMS6R3GCNvD4LTKvGH1Ev6YfUEY,14207
+ormlambda/sql/sqltypes.py,sha256=1Ir_Wxz1VjnNOh2zzIf7P7w4tbY0ljlubZMoAEiUkYU,14333
 ormlambda/sql/table/__init__.py,sha256=LLZcMLjwFxgBCPhdm5UQYYZDIbtYWCKPO9CbcXsy5zI,50
 ormlambda/sql/table/fields.py,sha256=ovNR3bJ473aKW-2NhbKr0iJlVpgW06jurHLob2IyZU8,2116
 ormlambda/sql/table/table.py,sha256=U8ByMDEEXIOwfPykDcjzoyNV1WEieN40Zk18EXveX60,6594
 ormlambda/sql/table/table_constructor.py,sha256=c3Z-1El0onSClYBmAatoUBYUOT70tITVqtsDJMxZ9QU,1092
-ormlambda/sql/type_api.py,sha256=FdEUBpdPbHIag--OU3mHY8vxMqyyzTMYygDBCUvGlcU,980
+ormlambda/sql/type_api.py,sha256=vepqMw6hR4zVhhNIYbtX491iVsxAfwHiSiD3uYQUGTE,1067
 ormlambda/sql/types.py,sha256=lQxC5gbhDPRckGSRJZ4rYSZr-XUvIMMH8WfkN1wtM1g,844
-ormlambda/sql/visitors.py,sha256=FJdnaiF86xK699Kq1qfHFSPtmeVsDX_PaUNHAoP8Tck,1967
+ormlambda/sql/visitors.py,sha256=AHXxCEOME8-b_-YhFEzBv-Jd15vSoX5F-jEGrPPNRLE,2052
 ormlambda/statements/__init__.py,sha256=kmd5K0dXiLQ2xTYlhd2yXeG2l955RtpDkrAIkZlfad8,148
 ormlambda/statements/base_statement.py,sha256=Dw89C2-eSwtuNc8UqzQMkoVuykf0gIWyA81YoXu6CQQ,4985
 ormlambda/statements/interfaces/IStatements.py,sha256=b2eQBeEoRivehhopmm-gca6qRSZ3ld06YMEHQEVP1d8,12824
@@ -150,8 +150,8 @@ ormlambda/util/module_tree/dfs_traversal.py,sha256=lSF03G63XtJFLp03ueAmsHMBvhUkj
 ormlambda/util/module_tree/dynamic_module.py,sha256=vJOqvm5-WKksudXBK1IcTn4WsuLxt1qXNISq-_21sy4,8705
 ormlambda/util/plugin_loader.py,sha256=p6WLn-MF1bQd2i2GHy98WQjNKmbQdqIUyTFIcBIHC5M,1034
 ormlambda/util/typing.py,sha256=Z7irz53ui0hoFnJTe06NX4JPl60_thgdjJIxh5gjGGk,169
-ormlambda-3.34.1.dist-info/AUTHORS,sha256=uWpOHaCPTOLbVkk5x9McoLwbgzSeCg7yILeDRyMGWGM,606
-ormlambda-3.34.1.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
-ormlambda-3.34.1.dist-info/METADATA,sha256=q1FalyMLHthaHwhaCbL2lzNdIq6pkyZdvoVQSeb-Tas,13326
-ormlambda-3.34.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-ormlambda-3.34.1.dist-info/RECORD,,
+ormlambda-3.34.6.dist-info/AUTHORS,sha256=uWpOHaCPTOLbVkk5x9McoLwbgzSeCg7yILeDRyMGWGM,606
+ormlambda-3.34.6.dist-info/LICENSE,sha256=xBprFw8GJLdHMOoUqDk0427EvjIcbEREvXXVFULuuXU,1080
+ormlambda-3.34.6.dist-info/METADATA,sha256=dLX5_MrsxoSEMj42Ummw8Cnv7E8829nPkqxLQCH6V4o,13326
+ormlambda-3.34.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ormlambda-3.34.6.dist-info/RECORD,,