SQLAlchemy 2.1.0rc1__cp315-cp315-win_amd64.whl

sqlalchemy/dialects/mysql/__init__.py

@@ -0,0 +1,106 @@
+# dialects/mysql/__init__.py
+# Copyright (C) 2005-2026 the SQLAlchemy authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: https://www.opensource.org/licenses/mit-license.php
+# mypy: ignore-errors
+
+
+from . import aiomysql  # noqa
+from . import asyncmy  # noqa
+from . import base  # noqa
+from . import cymysql  # noqa
+from . import mariadbconnector  # noqa
+from . import mysqlconnector  # noqa
+from . import mysqldb  # noqa
+from . import pymysql  # noqa
+from . import pyodbc  # noqa
+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 ENUM
+from .base import FLOAT
+from .base import INTEGER
+from .base import JSON
+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 SET
+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
+from .dml import Insert
+from .dml import insert
+from .dml import limit
+from .expression import match
+from .mariadb import INET4
+from .mariadb import INET6
+
+# default dialect
+base.dialect = dialect = mysqldb.dialect
+
+__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",
+    "limit",
+)

sqlalchemy/dialects/mysql/_mariadb_shim.py

@@ -0,0 +1,312 @@
+# dialects/mysql/_mariadb_shim.py
+# Copyright (C) 2005-2026 the SQLAlchemy authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: https://www.opensource.org/licenses/mit-license.php
+
+from __future__ import annotations
+
+from typing import Any
+from typing import cast
+from typing import Optional
+from typing import Type
+from typing import TYPE_CHECKING
+
+from .reserved_words import RESERVED_WORDS_MARIADB
+from ... import exc
+from ... import schema as sa_schema
+from ... import util
+from ...engine import cursor as _cursor
+from ...engine import default
+from ...engine.default import DefaultDialect
+from ...engine.interfaces import TypeCompiler
+from ...sql import elements
+from ...sql import sqltypes
+from ...sql.compiler import DDLCompiler
+from ...sql.compiler import IdentifierPreparer
+from ...sql.compiler import SQLCompiler
+from ...sql.schema import SchemaConst
+from ...sql.sqltypes import _UUID_RETURN
+from ...sql.sqltypes import UUID
+from ...sql.sqltypes import Uuid
+
+if TYPE_CHECKING:
+    from .base import MySQLIdentifierPreparer
+    from .mariadb import INET4
+    from .mariadb import INET6
+    from ...engine import URL
+    from ...engine.base import Connection
+    from ...sql import ddl
+    from ...sql.schema import IdentityOptions
+    from ...sql.schema import Sequence as Sequence_SchemaItem
+    from ...sql.type_api import _BindProcessorType
+
+
+class _MariaDBUUID(UUID[_UUID_RETURN]):
+    def __init__(self, as_uuid: bool = True, native_uuid: bool = True):
+        self.as_uuid = as_uuid
+
+        # the _MariaDBUUID internal type is only invoked for a Uuid() with
+        # native_uuid=True.   for non-native uuid type, the plain Uuid
+        # returns itself due to the workings of the Emulated superclass.
+        assert native_uuid
+
+        # for internal type, force string conversion for result_processor() as
+        # current drivers are returning a string, not a Python UUID object
+        self.native_uuid = False
+
+    @property
+    def native(self) -> bool:  # type: ignore[override]
+        # override to return True, this is a native type, just turning
+        # off native_uuid for internal data handling
+        return True
+
+    def bind_processor(self, dialect: MariaDBShim) -> Optional[_BindProcessorType[_UUID_RETURN]]:  # type: ignore[override] # noqa: E501
+        if not dialect.supports_native_uuid or not dialect._allows_uuid_binds:
+            return super().bind_processor(dialect)  # type: ignore[return-value] # noqa: E501
+        else:
+            return None
+
+
+class MariaDBTypeCompilerShim(TypeCompiler):
+    def visit_INET4(self, type_: INET4, **kwargs: Any) -> str:
+        return "INET4"
+
+    def visit_INET6(self, type_: INET6, **kwargs: Any) -> str:
+        return "INET6"
+
+
+class MariadbExecutionContextShim(default.DefaultExecutionContext):
+    def post_exec(self) -> None:
+        if (
+            self.isdelete
+            and cast(SQLCompiler, self.compiled).effective_returning
+            and not self.cursor.description
+        ):
+            # All MySQL/mariadb drivers appear to not include
+            # cursor.description for DELETE..RETURNING with no rows if the
+            # WHERE criteria is a straight "false" condition such as our EMPTY
+            # IN condition. manufacture an empty result in this case (issue
+            # #10505)
+            #
+            # taken from cx_Oracle implementation
+            self.cursor_fetch_strategy = (
+                _cursor.FullyBufferedCursorFetchStrategy(
+                    self.cursor,
+                    [
+                        (entry.keyname, None)  # type: ignore[misc]
+                        for entry in cast(
+                            SQLCompiler, self.compiled
+                        )._result_columns
+                    ],
+                    [],
+                )
+            )
+
+    def fire_sequence(
+        self, seq: Sequence_SchemaItem, type_: sqltypes.Integer
+    ) -> int:
+        return self._execute_scalar(  # type: ignore[no-any-return]
+            (
+                "select nextval(%s)"
+                % self.identifier_preparer.format_sequence(seq)
+            ),
+            type_,
+        )
+
+
+class MariaDBIdentifierPreparerShim(IdentifierPreparer):
+    def _set_mariadb(self) -> None:
+        self.reserved_words = RESERVED_WORDS_MARIADB
+
+
+class MariaDBSQLCompilerShim(SQLCompiler):
+    def visit_sequence(self, sequence: sa_schema.Sequence, **kw: Any) -> str:
+        return "nextval(%s)" % self.preparer.format_sequence(sequence)
+
+    def _mariadb_regexp_flags(
+        self, flags: str, pattern: elements.ColumnElement[Any], **kw: Any
+    ) -> str:
+        return "CONCAT('(?', %s, ')', %s)" % (
+            self.render_literal_value(flags, sqltypes.STRINGTYPE),
+            self.process(pattern, **kw),
+        )
+
+    def _mariadb_regexp_match(
+        self,
+        op_string: str,
+        binary: elements.BinaryExpression[Any],
+        operator: Any,
+        **kw: Any,
+    ) -> str:
+        flags = binary.modifiers["flags"]
+        return "%s%s%s" % (
+            self.process(binary.left, **kw),
+            op_string,
+            self._mariadb_regexp_flags(flags, binary.right),
+        )
+
+    def _mariadb_regexp_replace_op_binary(
+        self, binary: elements.BinaryExpression[Any], operator: Any, **kw: Any
+    ) -> str:
+        flags = binary.modifiers["flags"]
+        return "REGEXP_REPLACE(%s, %s, %s)" % (
+            self.process(binary.left, **kw),
+            self._mariadb_regexp_flags(flags, binary.right.clauses[0]),
+            self.process(binary.right.clauses[1], **kw),
+        )
+
+    def _mariadb_visit_drop_check_constraint(
+        self, drop: ddl.DropConstraint, **kw: Any
+    ) -> str:
+        constraint = drop.element
+        qual = "CONSTRAINT "
+        const = self.preparer.format_constraint(constraint)
+        return "ALTER TABLE %s DROP %s%s" % (
+            self.preparer.format_table(constraint.table),
+            qual,
+            const,
+        )
+
+
+class MariaDBDDLCompilerShim(DDLCompiler):
+    dialect: MariaDBShim
+
+    def _mariadb_get_column_specification(
+        self, column: sa_schema.Column[Any], **kw: Any
+    ) -> str:
+
+        if (
+            column.computed is not None
+            and column._user_defined_nullable is SchemaConst.NULL_UNSPECIFIED
+        ):
+            kw["_force_column_to_nullable"] = True
+
+        return self._mysql_get_column_specification(column, **kw)
+
+    def _mysql_get_column_specification(
+        self,
+        column: sa_schema.Column[Any],
+        *,
+        _force_column_to_nullable: bool = False,
+        **kw: Any,
+    ) -> str:
+        raise NotImplementedError()
+
+    def get_identity_options(self, identity_options: IdentityOptions) -> str:
+        text = super().get_identity_options(identity_options)
+        text = text.replace("NO CYCLE", "NOCYCLE")
+        return text
+
+    def _mariadb_visit_drop_check_constraint(
+        self, drop: ddl.DropConstraint, **kw: Any
+    ) -> str:
+        constraint = drop.element
+        qual = "CONSTRAINT "
+        const = self.preparer.format_constraint(constraint)
+        return "ALTER TABLE %s DROP %s%s" % (
+            self.preparer.format_table(constraint.table),
+            qual,
+            const,
+        )
+
+
+class MariaDBShim(DefaultDialect):
+    server_version_info: tuple[int, ...]
+    is_mariadb: bool
+    _allows_uuid_binds = False
+
+    identifier_preparer: MySQLIdentifierPreparer
+    preparer: Type[MySQLIdentifierPreparer]
+
+    def _set_mariadb(
+        self, is_mariadb: Optional[bool], server_version_info: tuple[int, ...]
+    ) -> None:
+        if is_mariadb is None:
+            return
+
+        if not is_mariadb and self.is_mariadb:
+            raise exc.InvalidRequestError(
+                "MySQL version %s is not a MariaDB variant."
+                % (".".join(map(str, server_version_info)),)
+            )
+        if is_mariadb:
+            assert isinstance(self.colspecs, dict)
+            self.colspecs = util.update_copy(
+                self.colspecs, {Uuid: _MariaDBUUID}
+            )
+
+            self.identifier_preparer = self.preparer(self)
+            self.identifier_preparer._set_mariadb()
+
+            # this will be updated on first connect in initialize()
+            # if using older mariadb version
+            self.delete_returning = True
+            self.insert_returning = True
+
+        self.is_mariadb = is_mariadb
+
+    @property
+    def _mariadb_normalized_version_info(self) -> tuple[int, ...]:
+        return self.server_version_info
+
+    @property
+    def _is_mariadb(self) -> bool:
+        return self.is_mariadb
+
+    @classmethod
+    def _is_mariadb_from_url(cls, url: URL) -> bool:
+        dbapi = cls.import_dbapi()
+        dialect = cls(dbapi=dbapi)
+
+        cargs, cparams = dialect.create_connect_args(url)
+        conn = dialect.connect(*cargs, **cparams)
+        try:
+            cursor = conn.cursor()
+            cursor.execute("SELECT VERSION() LIKE '%MariaDB%'")
+            val = cursor.fetchone()[0]  # type: ignore[index]
+        except:
+            raise
+        else:
+            return bool(val)
+        finally:
+            conn.close()
+
+    def _initialize_mariadb(self, connection: Connection) -> None:
+        assert self.is_mariadb
+
+        self.supports_sequences = self.server_version_info >= (10, 3)
+
+        self.delete_returning = self.server_version_info >= (10, 0, 5)
+
+        self.insert_returning = self.server_version_info >= (10, 5)
+
+        self._warn_for_known_db_issues()
+
+        self.supports_native_uuid = (
+            self.server_version_info is not None
+            and self.server_version_info >= (10, 7)
+        )
+        self._allows_uuid_binds = True
+
+        # ref https://mariadb.com/kb/en/mariadb-1021-release-notes/
+        self._support_default_function = self.server_version_info >= (10, 2, 1)
+
+        # ref https://mariadb.com/kb/en/mariadb-1045-release-notes/
+        self._support_float_cast = self.server_version_info >= (10, 4, 5)
+
+    def _warn_for_known_db_issues(self) -> None:
+        if self.is_mariadb:
+            mdb_version = self.server_version_info
+            assert mdb_version is not None
+            if mdb_version > (10, 2) and mdb_version < (10, 2, 9):
+                util.warn(
+                    "MariaDB %r before 10.2.9 has known issues regarding "
+                    "CHECK constraints, which impact handling of NULL values "
+                    "with SQLAlchemy's boolean datatype (MDEV-13596). An "
+                    "additional issue prevents proper migrations of columns "
+                    "with CHECK constraints (MDEV-11114).  Please upgrade to "
+                    "MariaDB 10.2.9 or greater, or use the MariaDB 10.1 "
+                    "series, to avoid these issues." % (mdb_version,)
+                )

sqlalchemy/dialects/mysql/aiomysql.py

@@ -0,0 +1,260 @@
+# dialects/mysql/aiomysql.py
+# Copyright (C) 2005-2026 the SQLAlchemy authors and contributors <see AUTHORS
+# file>
+#
+# This module is part of SQLAlchemy and is released under
+# the MIT License: https://www.opensource.org/licenses/mit-license.php
+
+r"""
+.. dialect:: mysql+aiomysql
+    :name: aiomysql
+    :dbapi: aiomysql
+    :connectstring: mysql+aiomysql://user:password@host:port/dbname[?key=value&key=value...]
+    :url: https://github.com/aio-libs/aiomysql
+
+The aiomysql dialect is SQLAlchemy's second Python asyncio dialect.
+
+Using a special asyncio mediation layer, the aiomysql dialect is usable
+as the backend for the :ref:`SQLAlchemy asyncio <asyncio_toplevel>`
+extension package.
+
+This dialect should normally be used only with the
+:func:`_asyncio.create_async_engine` engine creation function::
+
+    from sqlalchemy.ext.asyncio import create_async_engine
+
+    engine = create_async_engine(
+        "mysql+aiomysql://user:pass@hostname/dbname?charset=utf8mb4"
+    )
+
+"""  # noqa
+
+from __future__ import annotations
+
+from types import ModuleType
+from typing import Any
+from typing import Optional
+from typing import TYPE_CHECKING
+from typing import Union
+
+from .pymysql import _connection_ping_reconnects_true
+from .pymysql import MySQLDialect_pymysql
+from ... import util
+from ...connectors.asyncio import AsyncAdapt_dbapi_connection
+from ...connectors.asyncio import AsyncAdapt_dbapi_cursor
+from ...connectors.asyncio import AsyncAdapt_dbapi_module
+from ...connectors.asyncio import AsyncAdapt_dbapi_ss_cursor
+from ...connectors.asyncio import AsyncAdapt_terminate
+from ...util import langhelpers
+from ...util.concurrency import await_
+
+if TYPE_CHECKING:
+
+    from ...connectors.asyncio import AsyncIODBAPIConnection
+    from ...connectors.asyncio import AsyncIODBAPICursor
+    from ...engine.interfaces import ConnectArgsType
+    from ...engine.interfaces import DBAPIConnection
+    from ...engine.interfaces import DBAPICursor
+    from ...engine.interfaces import DBAPIModule
+    from ...engine.interfaces import PoolProxiedConnection
+    from ...engine.url import URL
+
+
+class AsyncAdapt_aiomysql_cursor(AsyncAdapt_dbapi_cursor):
+    __slots__ = ()
+
+    def _make_new_cursor(
+        self, connection: AsyncIODBAPIConnection
+    ) -> AsyncIODBAPICursor:
+        return connection.cursor(self._adapt_connection.dbapi.Cursor)
+
+
+class AsyncAdapt_aiomysql_ss_cursor(
+    AsyncAdapt_dbapi_ss_cursor, AsyncAdapt_aiomysql_cursor
+):
+    __slots__ = ()
+
+    def _make_new_cursor(
+        self, connection: AsyncIODBAPIConnection
+    ) -> AsyncIODBAPICursor:
+        return connection.cursor(
+            self._adapt_connection.dbapi.aiomysql.cursors.SSCursor
+        )
+
+
+class AsyncAdapt_aiomysql_connection(
+    AsyncAdapt_terminate, AsyncAdapt_dbapi_connection
+):
+    __slots__ = ()
+
+    _cursor_cls = AsyncAdapt_aiomysql_cursor
+    _ss_cursor_cls = AsyncAdapt_aiomysql_ss_cursor
+
+    def ping(self, reconnect: bool = False) -> None:
+        assert not reconnect
+
+        if self.dbapi._send_false_to_ping:
+            await_(self._connection.ping(reconnect=False))
+        else:
+            await_(self._connection.ping())
+
+    def character_set_name(self) -> Optional[str]:
+        return self._connection.character_set_name()  # type: ignore[no-any-return]  # noqa: E501
+
+    def autocommit(self, value: Any) -> None:
+        await_(self._connection.autocommit(value))
+
+    def get_autocommit(self) -> bool:
+        return self._connection.get_autocommit()  # type: ignore[no-any-return]
+
+    def close(self) -> None:
+        await_(self._connection.ensure_closed())
+
+    async def _terminate_graceful_close(self) -> None:
+        await self._connection.ensure_closed()
+
+    def _terminate_force_close(self) -> None:
+        # it's not awaitable.
+        self._connection.close()
+
+
+class AsyncAdapt_aiomysql_dbapi(AsyncAdapt_dbapi_module):
+    def __init__(self, aiomysql: ModuleType, pymysql: ModuleType):
+        super().__init__(aiomysql, dbapi_module=pymysql)
+        self.aiomysql = aiomysql
+        self.pymysql = pymysql
+        self.paramstyle = "format"
+        self._init_dbapi_attributes()
+        self.Cursor, self.SSCursor = self._init_cursors_subclasses()
+
+    def _init_dbapi_attributes(self) -> None:
+        for name in (
+            "Warning",
+            "Error",
+            "InterfaceError",
+            "DataError",
+            "DatabaseError",
+            "OperationalError",
+            "InterfaceError",
+            "IntegrityError",
+            "ProgrammingError",
+            "InternalError",
+            "NotSupportedError",
+        ):
+            setattr(self, name, getattr(self.aiomysql, name))
+
+        for name in (
+            "NUMBER",
+            "STRING",
+            "DATETIME",
+            "BINARY",
+            "TIMESTAMP",
+            "Binary",
+        ):
+            setattr(self, name, getattr(self.pymysql, name))
+
+    def connect(self, *arg: Any, **kw: Any) -> AsyncAdapt_aiomysql_connection:
+        creator_fn = kw.pop("async_creator_fn", self.aiomysql.connect)
+
+        return await_(
+            AsyncAdapt_aiomysql_connection.create(
+                self,
+                creator_fn(*arg, **kw),
+            )
+        )
+
+    @langhelpers.memoized_property
+    def _send_false_to_ping(self) -> bool:
+        """determine if aiomysql has deprecated, changed the default of,
+        or removed the 'reconnect' argument of connection.ping().
+
+        See #13306 and #10492
+
+        """  # noqa: E501
+
+        try:
+            Connection = __import__(
+                "aiomysql.connection"
+            ).connection.Connection
+        except (ImportError, AttributeError):
+            return True
+        else:
+            return _connection_ping_reconnects_true(Connection)
+
+    def _init_cursors_subclasses(
+        self,
+    ) -> tuple[AsyncIODBAPICursor, AsyncIODBAPICursor]:
+        # suppress unconditional warning emitted by aiomysql
+        class Cursor(self.aiomysql.Cursor):  # type: ignore[misc, name-defined]
+            async def _show_warnings(
+                self, conn: AsyncIODBAPIConnection
+            ) -> None:
+                pass
+
+        class SSCursor(self.aiomysql.SSCursor):  # type: ignore[misc, name-defined]   # noqa: E501
+            async def _show_warnings(
+                self, conn: AsyncIODBAPIConnection
+            ) -> None:
+                pass
+
+        return Cursor, SSCursor  # type: ignore[return-value]
+
+
+class MySQLDialect_aiomysql(MySQLDialect_pymysql):
+    driver = "aiomysql"
+    supports_statement_cache = True
+
+    supports_server_side_cursors = True
+    _sscursor = AsyncAdapt_aiomysql_ss_cursor
+
+    is_async = True
+    has_terminate = True
+
+    @classmethod
+    def import_dbapi(cls) -> AsyncAdapt_aiomysql_dbapi:
+        return AsyncAdapt_aiomysql_dbapi(
+            __import__("aiomysql"), __import__("pymysql")
+        )
+
+    def retrieve_dbapi_version(self, dbapi: DBAPIModule) -> util.VersionInfo:
+        # the version of aiomysql itself, rather than that of the pymysql
+        # module it makes use of
+        aiomysql = getattr(dbapi, "aiomysql", None)
+        return util.parse_version_string(
+            getattr(aiomysql, "__version__", None)
+        )
+
+    def do_terminate(self, dbapi_connection: DBAPIConnection) -> None:
+        dbapi_connection.terminate()
+
+    def create_connect_args(
+        self, url: URL, _translate_args: Optional[dict[str, Any]] = None
+    ) -> ConnectArgsType:
+        return super().create_connect_args(
+            url, _translate_args=dict(username="user", database="db")
+        )
+
+    def is_disconnect(
+        self,
+        e: DBAPIModule.Error,
+        connection: Optional[Union[PoolProxiedConnection, DBAPIConnection]],
+        cursor: Optional[DBAPICursor],
+    ) -> bool:
+        if super().is_disconnect(e, connection, cursor):
+            return True
+        else:
+            str_e = str(e).lower()
+            return "not connected" in str_e
+
+    def _found_rows_client_flag(self) -> int:
+        from pymysql.constants import CLIENT  # type: ignore[import-untyped]
+
+        return CLIENT.FOUND_ROWS  # type: ignore[no-any-return]
+
+    def get_driver_connection(
+        self, connection: DBAPIConnection
+    ) -> AsyncIODBAPIConnection:
+        return connection._connection  # type: ignore[no-any-return]
+
+
+dialect = MySQLDialect_aiomysql