ormlambda 3.34.0__tar.gz → 3.34.5__tar.gz

{ormlambda-3.34.0 → ormlambda-3.34.5}/PKG-INFO

@@ -1,13 +1,12 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: ormlambda
-Version: 3.34.0
+Version: 3.34.5
 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
 Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: mysql-connector-python (>=9.0.0,<10.0.0)
 Requires-Dist: shapely (>=2.0.6,<3.0.0)
 Description-Content-Type: text/markdown

{ormlambda-3.34.0 → ormlambda-3.34.5}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.34.0"
+version = "3.34.5"
 description = "ORM designed to interact with the database (currently with MySQL) using lambda functions and nested functions"
 authors = ["p-hzamora <p.hzamora@icloud.com>"]
 readme = "README.md"

{ormlambda-3.34.0 → ormlambda-3.34.5}/src/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-3.34.5/src/ormlambda/databases/__init__.py

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

ormlambda-3.34.5/src/ormlambda/databases/my_sql/__init__.py

@@ -0,0 +1,3 @@
+from mysql.connector import MySQLConnection  # noqa: F401
+from .repository import MySQLRepository  # noqa: F401
+from .caster import MySQLCaster  # noqa: F401

{ormlambda-3.34.0/src/ormlambda/dialects/mysql → ormlambda-3.34.5/src/ormlambda/databases/my_sql}/caster/caster.py

@@ -12,11 +12,13 @@ from .types import (
     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):
@@ -31,9 +33,11 @@ class MySQLCaster(Caster):
             Point: PointCaster,
             NoneType: NoneTypeCaster,
             datetime: DatetimeCaster,
+            date: DatetimeCaster,
             bytes: BytesCaster,
             bytearray: BytesCaster,
             tuple: IterableCaster,
             list: IterableCaster,
             bool: BooleanCaster,
+            Decimal: DecimalCaster,
         }

{ormlambda-3.34.0/src/ormlambda/dialects/mysql → ormlambda-3.34.5/src/ormlambda/databases/my_sql}/caster/types/__init__.py

@@ -7,3 +7,5 @@ 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-3.34.5/src/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-3.34.5/src/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-3.34.0/src/ormlambda/dialects/mysql → ormlambda-3.34.5/src/ormlambda/databases/my_sql}/clauses/__init__.py

@@ -1,4 +1,5 @@
 from .delete import DeleteQuery as Delete
+from .drop_table import DropTable as DropTable
 from .insert import InsertQuery as Insert
 from .joins import JoinSelector as JoinSelector
 from .limit import Limit as Limit

ormlambda-3.34.5/src/ormlambda/databases/my_sql/clauses/drop_table.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from typing import Literal, override, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from mysql.connector import MySQLConnection
+
+from ormlambda.repository import BaseRepository
+
+
+TypeExists = Literal["fail", "replace", "append"]
+
+
+class DropTable:
+    def __init__(self, repository: BaseRepository[MySQLConnection]) -> None:
+        self._repository: BaseRepository[MySQLConnection] = repository
+
+    @override
+    def execute(self, name: str = None) -> None:
+        query = rf"{self.CLAUSE} {name}"
+        self._repository.execute(query)
+        return None
+
+    @property
+    @override
+    def CLAUSE(self) -> str:
+        return "DROP TABLE"

{ormlambda-3.34.0/src/ormlambda/dialects/mysql/repository → ormlambda-3.34.5/src/ormlambda/databases/my_sql}/repository.py

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

ormlambda-3.34.5/src/ormlambda/dialects/mysql/__init__.py

@@ -0,0 +1,8 @@
+from . import base
+from . import mysqlconnector
+
+# default dialect
+base.dialect = dialect = mysqlconnector.dialect
+
+
+from .types import *  # noqa: F403

{ormlambda-3.34.0 → ormlambda-3.34.5}/src/ormlambda/dialects/mysql/base.py

@@ -10,7 +10,10 @@ if TYPE_CHECKING:
 
 from .types import (
     _NumericType,
+    _NumericCommonType,
     _StringType,
+    VARCHAR,
+    CHAR,
     NUMERIC,
     DECIMAL,
     DOUBLE,
@@ -36,10 +39,17 @@ from .types import (
     MEDIUMBLOB,
     LONGBLOB,
 )
-from ormlambda.sql.sqltypes import BLOB
+from ormlambda.sql.sqltypes import (
+    LARGEBINARY,
+    BLOB,
+    BOOLEAN,
+    DATE,
+    UUID,
+    VARBINARY,
+)
+
 
-from .caster import MySQLCaster
-from .repository import MySQLRepository
+from ormlambda.databases.my_sql import MySQLRepository, MySQLCaster
 
 
 if TYPE_CHECKING:
@@ -74,7 +84,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)
@@ -111,7 +121,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)}"
 
@@ -123,7 +133,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
@@ -165,7 +175,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"):
@@ -185,183 +195,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):