ormlambda 3.34.1__tar.gz → 3.34.6__tar.gz

{ormlambda-3.34.1 → ormlambda-3.34.6}/PKG-INFO

@@ -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 → ormlambda-3.34.6}/pyproject.toml

@@ -3,7 +3,7 @@ line-length = 320
 
 [tool.poetry]
 name = "ormlambda"
-version = "3.34.1"
+version = "3.34.6"
 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.1 → ormlambda-3.34.6}/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.6/src/ormlambda/dialects/mysql/__init__.py

@@ -0,0 +1,84 @@
+from . import base
+from . import mysqlconnector
+
+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",
+)
+
+
+# default dialect
+base.dialect = dialect = mysqlconnector.dialect

{ormlambda-3.34.1 → ormlambda-3.34.6}/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,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-3.34.1 → ormlambda-3.34.6}/src/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-3.34.1 → ormlambda-3.34.6}/src/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)