SQLAlchemy 2.1.0b3__py3-none-any.whl → 2.1.0rc2__py3-none-any.whl

sqlalchemy/__init__.py

@@ -74,6 +74,7 @@ from .schema import ExecutableDDLElement as ExecutableDDLElement
 from .schema import FetchedValue as FetchedValue
 from .schema import ForeignKey as ForeignKey
 from .schema import ForeignKeyConstraint as ForeignKeyConstraint
+from .schema import ForeignKeyTarget as ForeignKeyTarget
 from .schema import Identity as Identity
 from .schema import Index as Index
 from .schema import insert_sentinel as insert_sentinel
@@ -284,7 +285,7 @@ from .types import Uuid as Uuid
 from .types import VARBINARY as VARBINARY
 from .types import VARCHAR as VARCHAR
 
-__version__ = "2.1.0b3"
+__version__ = "2.1.0rc2"
 
 
 def __go(lcls: Any) -> None:

sqlalchemy/connectors/asyncio.py

@@ -337,7 +337,7 @@ class AsyncAdapt_dbapi_ss_cursor(AsyncAdapt_dbapi_cursor):
     def close(self) -> None:
         if self._cursor is not None:
             await_(self._cursor.close())
-            self._cursor = None  # type: ignore
+            self._cursor = None  # type: ignore[assignment]
 
     def fetchone(self) -> Optional[Any]:
         return await_(self._cursor.fetchone())

sqlalchemy/connectors/pyodbc.py

@@ -164,25 +164,14 @@ class PyODBCConnector(Connector):
         else:
             return False
 
-    def _dbapi_version(self) -> interfaces.VersionInfoType:
-        if not self.dbapi:
-            return ()
-        return self._parse_dbapi_version(self.dbapi.version)
-
-    def _parse_dbapi_version(self, vers: str) -> interfaces.VersionInfoType:
-        m = re.match(r"(?:py.*-)?([\d\.]+)(?:-(\w+))?", vers)
-        if not m:
-            return ()
-        vers_tuple: interfaces.VersionInfoType = tuple(
-            [int(x) for x in m.group(1).split(".")]
-        )
-        if m.group(2):
-            vers_tuple += (m.group(2),)
-        return vers_tuple
+    def retrieve_dbapi_version(
+        self, dbapi: interfaces.DBAPIModule
+    ) -> util.VersionInfo:
+        return util.parse_version_string(dbapi.version)
 
     def _get_server_version_info(
         self, connection: Connection
-    ) -> interfaces.VersionInfoType:
+    ) -> interfaces.ServerVersionInfoType:
         # NOTE: this function is not reliable, particularly when
         # freetds is in use.   Implement database-specific server version
         # queries.

sqlalchemy/dialects/__init__.py

@@ -43,7 +43,7 @@ def _auto_fn(name: str) -> Optional[Callable[[], Type[Dialect]]]:
             module: Any = __import__(
                 "sqlalchemy.dialects.mysql.mariadb"
             ).dialects.mysql.mariadb
-            return module.loader(driver)  # type: ignore
+            return module.loader(driver)  # type: ignore[no-any-return]
         else:
             module = __import__("sqlalchemy.dialects.%s" % (dialect,)).dialects
             module = getattr(module, dialect)

sqlalchemy/dialects/mssql/base.py

@@ -1561,7 +1561,7 @@ class MSUUid(sqltypes.Uuid):
         if self.native_uuid:
 
             def process(value):
-                return f"""'{str(value).replace("''", "'")}'"""
+                return f"""'{str(value).replace("'", "''")}'"""
 
             return process
         else:
@@ -3373,11 +3373,29 @@ class MSDialect(default._BackendsMultiReflection, default.DefaultDialect):
         else:
             return self.schema_name
 
+    @reflection.cache
     @_db_plus_owner
     def has_table(self, connection, tablename, dbname, owner, schema, **kw):
         self._ensure_has_table_connection(connection)
 
-        return self._internal_has_table(connection, tablename, owner, **kw)
+        return self._internal_has_multi_table(
+            connection, [tablename], owner, schema, **kw
+        )[schema, tablename]
+
+    def has_multi_table(self, connection, table_names, schema=None, **kw):
+        # this does not really matche the signature of _db_plus_owner_multi
+        # so manually do the unpacking here
+        dbname, owner = _owner_plus_db(self, schema)
+        return _switch_db(
+            dbname,
+            connection,
+            self._internal_has_multi_table,
+            connection,
+            table_names,
+            owner,
+            schema,
+            **kw,
+        ).items()
 
     @reflection.cache
     @_db_plus_owner
@@ -3452,37 +3470,38 @@ class MSDialect(default._BackendsMultiReflection, default.DefaultDialect):
         view_names = [r[0] for r in connection.execute(s)]
         return view_names
 
-    @reflection.cache
-    def _internal_has_table(self, connection, tablename, owner, **kw):
-        if tablename.startswith("#"):  # temporary table
-            # mssql does not support temporary views
-            # SQL Error [4103] [S0001]: "#v": Temporary views are not allowed
-            return bool(
-                connection.scalar(
-                    # U filters on user tables only.
-                    text("SELECT object_id(:table_name, 'U')"),
-                    {"table_name": f"tempdb.dbo.[{tablename}]"},
-                )
-            )
-        else:
-            tables = ischema.tables
-
-            s = sql.select(tables.c.table_name).where(
-                sql.and_(
-                    sql.or_(
-                        tables.c.table_type == "BASE TABLE",
-                        tables.c.table_type == "VIEW",
-                    ),
-                    tables.c.table_name == tablename,
-                )
+    def _internal_has_multi_table(
+        self, connection, table_names, owner, schema, **kw
+    ):
+        regular_names, multi_object_names, temp_names = (
+            self._partition_filter_names(
+                connection, owner, table_names, ObjectScope.ANY, ObjectKind.ANY
             )
+        )
 
-            if owner:
-                s = s.where(tables.c.table_schema == owner)
+        result = {}
+        if multi_object_names:
+            # in multi_object_names we already have the names that exist in
+            # the database, no need to do another query here
+            name_map = self._multi_name_map(regular_names)
+            for server_name in multi_object_names:
+                result[(schema, name_map(server_name))] = True
 
-            c = connection.execute(s)
+        if temp_names:
+            # mssql does not support temporary views
+            # U filters on user tables only.
+            query = text("SELECT object_id(:table_name, 'U')")
+            for temp_name in temp_names:
+                result[(schema, temp_name)] = bool(
+                    connection.scalar(
+                        query,
+                        {"table_name": f"tempdb..[{temp_name}]"},
+                    )
+                )
 
-            return c.first() is not None
+        for name in table_names:
+            result.setdefault((schema, name), False)
+        return result
 
     @reflection.cache
     @_db_plus_owner
@@ -3570,14 +3589,20 @@ class MSDialect(default._BackendsMultiReflection, default.DefaultDialect):
 
         if coltype in (MSBinary, MSVarBinary, sqltypes.LargeBinary):
             kwargs["length"] = maxlen if maxlen != -1 else None
-        elif coltype in (MSString, MSChar, MSText):
+        elif coltype in (MSString, MSChar):
             kwargs["length"] = maxlen if maxlen != -1 else None
             if collation:
                 kwargs["collation"] = collation
-        elif coltype in (MSNVarchar, MSNChar, MSNText):
+        elif coltype in (MSNVarchar, MSNChar):
             kwargs["length"] = maxlen // 2 if maxlen != -1 else None
             if collation:
                 kwargs["collation"] = collation
+        elif coltype in (MSText, MSNText):
+            # TEXT / NTEXT are unlengthed LOB types.  sys.columns.max_length
+            # reports 16 for these, which is the size of the in-row LOB
+            # pointer and not a character length, so no length is applied.
+            if collation:
+                kwargs["collation"] = collation
 
         if coltype is None:
             if base_type is not None and base_type != type_:
@@ -3853,6 +3878,34 @@ index_info AS (
 
     # --- multi-reflection API ---
 
+    @lru_cache
+    def _partition_filter_names_query(self, add_filter_names: bool):
+        sys_objects = ischema.sys_objects
+        sys_schemas = ischema.sys_schemas
+
+        s = (
+            sql.select(sys_objects.c.name)
+            .select_from(sys_objects)
+            .join(
+                sys_schemas,
+                onclause=sys_objects.c.schema_id == sys_schemas.c.schema_id,
+            )
+            .where(
+                sys_schemas.c.name == sql.bindparam("schema"),
+                sys_objects.c.type.in_(
+                    sql.bindparam("type_filter", expanding=True)
+                ),
+            )
+        )
+        if add_filter_names:
+            s = s.where(
+                sys_objects.c.name.in_(
+                    sql.bindparam("filter_names", expanding=True)
+                )
+            )
+
+        return s
+
     def _partition_filter_names(
         self, connection, owner, filter_names, scope, kind
     ):
@@ -3914,29 +3967,20 @@ index_info AS (
 
         type_filter = []
         if ObjectKind.TABLE in kind:
-            type_filter.append("'U'")
+            type_filter.append("U")
         if ObjectKind.VIEW in kind:
-            type_filter.append("'V'")
+            type_filter.append("V")
         # SQL Server does not support materialized views, so ignore them
         if not type_filter:
             return (regular_names, [], temp_names)
 
-        query = (
-            "SELECT o.name "
-            "FROM sys.objects o "
-            "JOIN sys.schemas s ON o.schema_id = s.schema_id "
-            "WHERE s.name = :owner "
-            "AND o.type IN (%s)" % ", ".join(type_filter)
-        )
-        params = [sql.bindparam("owner", owner, ischema.CoerceUnicode())]
-        if regular_names:
-            query += " AND o.name IN :filter_names"
-            params.append(
-                sql.bindparam("filter_names", regular_names, expanding=True)
-            )
+        has_regular_names = bool(regular_names)
+        query = self._partition_filter_names_query(has_regular_names)
+        params = {"schema": owner, "type_filter": type_filter}
+        if has_regular_names:
+            params["filter_names"] = regular_names
 
-        rp = connection.execute(sql.text(query).bindparams(*params))
-        multi_object_names = [row[0] for row in rp]
+        multi_object_names = connection.scalars(query, params).all()
 
         return (regular_names, multi_object_names, temp_names)
 
@@ -4305,9 +4349,13 @@ index_info AS (
         # return empty foreign_keys for temp tables that exist. We
         # preserve that here by checking existence and returning the
         # default (empty) reflection for each temp that is reachable.
+        has_temp_tables = self._internal_has_multi_table(
+            connection, temp_names, owner="dbo", schema=schema, **kw
+        )
         for name in temp_names:
-            if self._internal_has_table(connection, name, owner="dbo"):
-                final[(schema, name)] = ReflectionDefaults.foreign_keys()
+            key = (schema, name)
+            if has_temp_tables.get(key):
+                final[key] = ReflectionDefaults.foreign_keys()
 
         return final.items()
 

sqlalchemy/dialects/mssql/mssqlpython.py

@@ -83,6 +83,24 @@ class MSDialect_mssqlpython(MSDialect):
 
     supports_native_decimal = True
 
+    _disconnect_driver_errors = frozenset(
+        {
+            # mssql-python converts the originating SQLSTATE into these
+            # values and exposes them on ``Exception.driver_error``.
+            "Disconnect error",  # 01002
+            "Client unable to establish connection",  # 08001
+            "Connection not open",  # 08003
+            "Connection failure during transaction",  # 08007
+            "Communication link failure",  # 08S01
+            # mssql-python does not map these SQLSTATE values to a
+            # dedicated driver error yet.
+            "An error occurred with SQLSTATE code: 08S02",
+            "An error occurred with SQLSTATE code: 10054",
+            "Connection timeout expired",  # HYT01
+            "Function sequence error",  # HY010
+        }
+    )
+
     # used by pyodbc _ms_numeric_pyodbc class
     _need_decimal_fix = True
 
@@ -163,32 +181,30 @@ class MSDialect_mssqlpython(MSDialect):
         ],
         cursor: Optional[interfaces.DBAPICursor],
     ) -> bool:
+        if not isinstance(e, self.loaded_dbapi.Error):
+            return False
+
+        if getattr(e, "driver_error", None) in self._disconnect_driver_errors:
+            return True
+
         if isinstance(e, self.loaded_dbapi.ProgrammingError):
             return (
                 "The cursor's connection has been closed." in str(e)
                 or "Attempt to use a closed connection." in str(e)
                 or "Driver Error: Operation cannot be performed" in str(e)
             )
-        elif isinstance(e, self.loaded_dbapi.InterfaceError):
-            return bool(re.search(r"Cannot .* on closed connection", str(e)))
-        else:
-            return False
 
-    def _dbapi_version(self) -> interfaces.VersionInfoType:
-        if not self.dbapi:
-            return ()
-        return self._parse_dbapi_version(self.dbapi.version)
-
-    def _parse_dbapi_version(self, vers: str) -> interfaces.VersionInfoType:
-        m = re.match(r"(?:py.*-)?([\d\.]+)(?:-(\w+))?", vers)
-        if not m:
-            return ()
-        vers_tuple: interfaces.VersionInfoType = tuple(
-            [int(x) for x in m.group(1).split(".")]
-        )
-        if m.group(2):
-            vers_tuple += (m.group(2),)
-        return vers_tuple
+        if isinstance(e, self.loaded_dbapi.InterfaceError):
+            return bool(
+                re.search(r"Cannot .* on (?:a )?closed connection", str(e))
+            )
+
+        return False
+
+    def retrieve_dbapi_version(
+        self, dbapi: interfaces.DBAPIModule
+    ) -> util.VersionInfo:
+        return util.parse_version_string(dbapi.version)
 
     def _get_server_version_info(self, connection):
         vers = connection.exec_driver_sql("select @@version").scalar()

sqlalchemy/dialects/mssql/pymssql.py

@@ -61,11 +61,14 @@ class MSDialect_pymssql(MSDialect):
         {sqltypes.Numeric: _MSNumeric_pymssql, sqltypes.Float: sqltypes.Float},
     )
 
+    def retrieve_dbapi_version(self, dbapi):
+        return util.parse_version_string(getattr(dbapi, "__version__", None))
+
     @classmethod
     def import_dbapi(cls):
         module = __import__("pymssql")
         # pymmsql < 2.1.1 doesn't have a Binary method.  we use string
-        client_ver = tuple(int(x) for x in module.__version__.split("."))
+        client_ver = util.parse_version_string(module.__version__)
         if client_ver < (2, 1, 1):
             # TODO: monkeypatching here is less than ideal
             module.Binary = lambda x: x if hasattr(x, "decode") else str(x)

sqlalchemy/dialects/mssql/pyodbc.py

@@ -606,10 +606,10 @@ class MSDialect_pyodbc(PyODBCConnector, MSDialect):
             and self.dbapi
             and hasattr(self.dbapi.Cursor, "nextset")
         )
-        self._need_decimal_fix = self.dbapi and self._dbapi_version() < (
-            2,
-            1,
-            8,
+        # a version which can't be determined is assumed to be an old one
+        version = self._dbapi_version_or_none
+        self._need_decimal_fix = bool(self.dbapi) and (
+            version is None or version < (2, 1, 8)
         )
         self.fast_executemany = fast_executemany
         if fast_executemany:

sqlalchemy/dialects/mysql/aiomysql.py

@@ -39,6 +39,7 @@ 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
@@ -104,7 +105,7 @@ class AsyncAdapt_aiomysql_connection(
         await_(self._connection.autocommit(value))
 
     def get_autocommit(self) -> bool:
-        return self._connection.get_autocommit()  # type: ignore
+        return self._connection.get_autocommit()  # type: ignore[no-any-return]
 
     def close(self) -> None:
         await_(self._connection.ensure_closed())
@@ -215,6 +216,14 @@ class MySQLDialect_aiomysql(MySQLDialect_pymysql):
             __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()
 
@@ -238,7 +247,7 @@ class MySQLDialect_aiomysql(MySQLDialect_pymysql):
             return "not connected" in str_e
 
     def _found_rows_client_flag(self) -> int:
-        from pymysql.constants import CLIENT  # type: ignore
+        from pymysql.constants import CLIENT  # type: ignore[import-untyped]
 
         return CLIENT.FOUND_ROWS  # type: ignore[no-any-return]
 

sqlalchemy/dialects/mysql/asyncmy.py

@@ -116,7 +116,7 @@ class AsyncAdapt_asyncmy_connection(
         await_(self._connection.autocommit(value))
 
     def get_autocommit(self) -> bool:
-        return self._connection.get_autocommit()  # type: ignore
+        return self._connection.get_autocommit()  # type: ignore[no-any-return]
 
     def close(self) -> None:
         await_(self._connection.ensure_closed())
@@ -200,6 +200,11 @@ class MySQLDialect_asyncmy(MySQLDialect_pymysql):
     def import_dbapi(cls) -> DBAPIModule:
         return AsyncAdapt_asyncmy_dbapi(__import__("asyncmy"))
 
+    def retrieve_dbapi_version(self, dbapi: DBAPIModule) -> util.VersionInfo:
+        # asyncmy publishes no version of its own within the module, so
+        # the installed distribution is consulted
+        return util.parse_version_from_metadata("asyncmy")
+
     def do_terminate(self, dbapi_connection: DBAPIConnection) -> None:
         dbapi_connection.terminate()
 
@@ -223,7 +228,7 @@ class MySQLDialect_asyncmy(MySQLDialect_pymysql):
             )
 
     def _found_rows_client_flag(self) -> int:
-        from asyncmy.constants import CLIENT  # type: ignore
+        from asyncmy.constants import CLIENT  # type: ignore[import-not-found]
 
         return CLIENT.FOUND_ROWS  # type: ignore[no-any-return]
 

sqlalchemy/dialects/mysql/base.py

@@ -1149,6 +1149,7 @@ from ...types import DATE
 from ...types import LargeBinary
 from ...types import UUID
 from ...types import VARBINARY
+from ...util import OrderedSet
 from ...util import topological
 
 if TYPE_CHECKING:
@@ -2135,8 +2136,8 @@ class MySQLDDLCompiler(
             "SUBPARTITION_BY",
         ]
 
-        nonpart_options = set(opts).difference(partition_options)
-        part_options = set(opts).intersection(partition_options)
+        nonpart_options = OrderedSet(opts).difference(partition_options)
+        part_options = OrderedSet(opts).intersection(partition_options)
 
         for opt in topological.sort(
             [
@@ -2976,9 +2977,9 @@ class MySQLDialect(_mariadb_shim.MariaDBShim, default.DefaultDialect):
         if isinstance(
             e,
             (
-                self.dbapi.OperationalError,  # type: ignore
-                self.dbapi.ProgrammingError,  # type: ignore
-                self.dbapi.InterfaceError,  # type: ignore
+                self.dbapi.OperationalError,  # type: ignore[union-attr]
+                self.dbapi.ProgrammingError,  # type: ignore[union-attr]
+                self.dbapi.InterfaceError,  # type: ignore[union-attr]
             ),
         ) and self._extract_error_code(e) in (
             1927,
@@ -2991,7 +2992,7 @@ class MySQLDialect(_mariadb_shim.MariaDBShim, default.DefaultDialect):
         ):
             return True
         elif isinstance(
-            e, (self.dbapi.InterfaceError, self.dbapi.InternalError)  # type: ignore  # noqa: E501
+            e, (self.dbapi.InterfaceError, self.dbapi.InternalError)  # type: ignore[union-attr]  # noqa: E501
         ):
             # if underlying connection is closed,
             # this is the error you get
@@ -3087,7 +3088,7 @@ class MySQLDialect(_mariadb_shim.MariaDBShim, default.DefaultDialect):
             #
             # there's more "doesn't exist" kinds of messages but they are
             # less clear if mysql 8 would suddenly start using one of those
-            if self._extract_error_code(e.orig) in (1146, 1049, 1051):  # type: ignore  # noqa: E501
+            if self._extract_error_code(e.orig) in (1146, 1049, 1051):  # type: ignore[arg-type, operator]  # noqa: E501
                 return False
             raise
 
@@ -3224,7 +3225,7 @@ class MySQLDialect(_mariadb_shim.MariaDBShim, default.DefaultDialect):
         if schema is not None:
             current_schema: str = schema
         else:
-            current_schema = self.default_schema_name  # type: ignore
+            current_schema = self.default_schema_name  # type: ignore[assignment]  # noqa: E501
 
         charset = self._connection_charset
 
@@ -3385,7 +3386,7 @@ class MySQLDialect(_mariadb_shim.MariaDBShim, default.DefaultDialect):
             def lower(s: str) -> str:
                 return s
 
-        default_schema_name: str = connection.dialect.default_schema_name  # type: ignore  # noqa: E501
+        default_schema_name: str = connection.dialect.default_schema_name  # type: ignore[assignment]  # noqa: E501
 
         # NOTE: using (table_schema, table_name, lower(column_name)) in (...)
         # is very slow since mysql does not seem able to properly use indexse.

sqlalchemy/dialects/mysql/enumerated.py

@@ -257,7 +257,7 @@ class SET(_StringType):
                 if value is not None and not isinstance(value, (int, str)):
                     value = ",".join(value)
                 if super_convert:
-                    return super_convert(value)  # type: ignore
+                    return super_convert(value)  # type: ignore[arg-type, no-any-return]  # noqa: E501
                 else:
                     return value
 

sqlalchemy/dialects/mysql/mariadbconnector.py

@@ -30,7 +30,6 @@ be ``mysqldb``. ``mariadb+mariadbconnector://`` is required to use this driver.
 
 from __future__ import annotations
 
-import re
 from typing import Any
 from typing import Optional
 from typing import Sequence
@@ -60,7 +59,7 @@ if TYPE_CHECKING:
     from ...sql.type_api import _ResultProcessorType
 
 
-mariadb_cpy_minimum_version = (1, 0, 1)
+mariadb_cpy_minimum_version = util.VersionInfo((1, 0, 1))
 
 
 class _MariaDBUUID(sqltypes.UUID[sqltypes._UUID_RETURN]):
@@ -125,6 +124,8 @@ class MySQLDialect_mariadbconnector(MySQLDialect):
     driver = "mariadbconnector"
     supports_statement_cache = True
 
+    minimum_dbapi_version = mariadb_cpy_minimum_version
+
     # set this to True at the module level to prevent the driver from running
     # against a backend that server detects as MySQL. currently this appears to
     # be unnecessary as MariaDB client libraries have always worked against
@@ -151,30 +152,12 @@ class MySQLDialect_mariadbconnector(MySQLDialect):
         MySQLDialect.colspecs, {sqltypes.Uuid: _MariaDBUUID}
     )
 
-    @util.memoized_property
-    def _dbapi_version(self) -> tuple[int, ...]:
-        if self.dbapi and hasattr(self.dbapi, "__version__"):
-            return tuple(
-                [
-                    int(x)
-                    for x in re.findall(
-                        r"(\d+)(?:[-\.]?|$)", self.dbapi.__version__
-                    )
-                ]
-            )
-        else:
-            return (99, 99, 99)
+    def retrieve_dbapi_version(self, dbapi: DBAPIModule) -> util.VersionInfo:
+        return util.parse_version_string(getattr(dbapi, "__version__", None))
 
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self.paramstyle = "qmark"
-        if self.dbapi is not None:
-            if self._dbapi_version < mariadb_cpy_minimum_version:
-                raise NotImplementedError(
-                    "The minimum required version for MariaDB "
-                    "Connector/Python is %s"
-                    % ".".join(str(x) for x in mariadb_cpy_minimum_version)
-                )
 
     @classmethod
     def import_dbapi(cls) -> DBAPIModule:

sqlalchemy/dialects/mysql/mysqlconnector.py

@@ -48,7 +48,6 @@ charset/collation will allow connectivity.
 
 from __future__ import annotations
 
-import re
 from typing import Any
 from typing import cast
 from typing import Optional
@@ -198,7 +197,7 @@ class MySQLDialect_mysqlconnector(MySQLDialect):
         # supports_sane_rowcount.
         if self.dbapi is not None:
             try:
-                from mysql.connector import constants  # type: ignore
+                from mysql.connector import constants  # type: ignore[import-not-found]  # noqa: E501
 
                 ClientFlag = constants.ClientFlag
 
@@ -212,19 +211,14 @@ class MySQLDialect_mysqlconnector(MySQLDialect):
 
         return [], opts
 
-    @util.memoized_property
-    def _mysqlconnector_version_info(self) -> Optional[tuple[int, ...]]:
-        if self.dbapi and hasattr(self.dbapi, "__version__"):
-            m = re.match(r"(\d+)\.(\d+)(?:\.(\d+))?", self.dbapi.__version__)
-            if m:
-                return tuple(int(x) for x in m.group(1, 2, 3) if x is not None)
-        return None
+    def retrieve_dbapi_version(self, dbapi: DBAPIModule) -> util.VersionInfo:
+        return util.parse_version_string(getattr(dbapi, "__version__", None))
 
     def _detect_charset(self, connection: Connection) -> str:
-        return connection.connection.charset  # type: ignore
+        return connection.connection.charset  # type: ignore[no-any-return]
 
     def _extract_error_code(self, exception: BaseException) -> int:
-        return exception.errno  # type: ignore
+        return exception.errno  # type: ignore[attr-defined, no-any-return]
 
     def is_disconnect(
         self,