sqlspec 0.47.0__cp314-cp314-win_amd64.whl

sqlspec/adapters/pymysql/data_dictionary.py

@@ -0,0 +1,120 @@
+"""MySQL-specific data dictionary for metadata queries via PyMySQL."""
+
+from typing import TYPE_CHECKING, ClassVar
+
+from mypy_extensions import mypyc_attr
+
+from sqlspec.data_dictionary.dialects.mysql import resolve_mysql_json_type
+from sqlspec.driver import SyncDataDictionaryBase
+from sqlspec.typing import ColumnMetadata, ForeignKeyMetadata, IndexMetadata, TableMetadata, VersionInfo
+
+if TYPE_CHECKING:
+    from sqlspec.adapters.pymysql.driver import PyMysqlDriver
+
+__all__ = ("PyMysqlDataDictionary",)
+
+
+@mypyc_attr(allow_interpreted_subclasses=True, native_class=False)
+class PyMysqlDataDictionary(SyncDataDictionaryBase):
+    """MySQL-specific sync data dictionary."""
+
+    dialect: ClassVar[str] = "mysql"
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def get_version(self, driver: "PyMysqlDriver") -> "VersionInfo | None":
+        """Get MySQL database version information."""
+        driver_id = id(driver)
+        # Inline cache check to avoid cross-module method call that causes mypyc segfault
+        if driver_id in self._version_fetch_attempted:
+            return self._version_cache.get(driver_id)
+        # Not cached, fetch from database
+
+        version_value = driver.select_value_or_none(self.get_query("version"))
+        if not version_value:
+            self._log_version_unavailable(type(self).dialect, "missing")
+            self.cache_version(driver_id, None)
+            return None
+
+        version_info = self.parse_version_with_pattern(self.get_dialect_config().version_pattern, str(version_value))
+        if version_info is None:
+            self._log_version_unavailable(type(self).dialect, "parse_failed")
+            self.cache_version(driver_id, None)
+            return None
+
+        self._log_version_detected(type(self).dialect, version_info)
+        self.cache_version(driver_id, version_info)
+        return version_info
+
+    def get_feature_flag(self, driver: "PyMysqlDriver", feature: str) -> bool:
+        """Check if MySQL database supports a specific feature."""
+        version_info = self.get_version(driver)
+        return self.resolve_feature_flag(feature, version_info)
+
+    def get_optimal_type(self, driver: "PyMysqlDriver", type_category: str) -> str:
+        """Get optimal MySQL type for a category."""
+        config = self.get_dialect_config()
+        version_info = self.get_version(driver)
+
+        if type_category == "json":
+            return resolve_mysql_json_type(version_info)
+
+        return config.get_optimal_type(type_category)
+
+    def get_tables(self, driver: "PyMysqlDriver", schema: "str | None" = None) -> "list[TableMetadata]":
+        """Get tables sorted by topological dependency order using the MySQL catalog."""
+        schema_name = self.resolve_schema(schema)
+        self._log_schema_introspect(driver, schema_name=schema_name, table_name=None, operation="tables")
+        return driver.select(self.get_query("tables_by_schema"), schema_name=schema_name, schema_type=TableMetadata)
+
+    def get_columns(
+        self, driver: "PyMysqlDriver", table: "str | None" = None, schema: "str | None" = None
+    ) -> "list[ColumnMetadata]":
+        """Get column information for a table or schema."""
+        schema_name = self.resolve_schema(schema)
+        if table is None:
+            self._log_schema_introspect(driver, schema_name=schema_name, table_name=None, operation="columns")
+            return driver.select(
+                self.get_query("columns_by_schema"), schema_name=schema_name, schema_type=ColumnMetadata
+            )
+
+        self._log_table_describe(driver, schema_name=schema_name, table_name=table, operation="columns")
+        return driver.select(
+            self.get_query("columns_by_table"), table_name=table, schema_name=schema_name, schema_type=ColumnMetadata
+        )
+
+    def get_indexes(
+        self, driver: "PyMysqlDriver", table: "str | None" = None, schema: "str | None" = None
+    ) -> "list[IndexMetadata]":
+        """Get index metadata for a table or schema."""
+        schema_name = self.resolve_schema(schema)
+        if table is None:
+            self._log_schema_introspect(driver, schema_name=schema_name, table_name=None, operation="indexes")
+            return driver.select(
+                self.get_query("indexes_by_schema"), schema_name=schema_name, schema_type=IndexMetadata
+            )
+
+        self._log_table_describe(driver, schema_name=schema_name, table_name=table, operation="indexes")
+        return driver.select(
+            self.get_query("indexes_by_table"), table_name=table, schema_name=schema_name, schema_type=IndexMetadata
+        )
+
+    def get_foreign_keys(
+        self, driver: "PyMysqlDriver", table: "str | None" = None, schema: "str | None" = None
+    ) -> "list[ForeignKeyMetadata]":
+        """Get foreign key metadata."""
+        schema_name = self.resolve_schema(schema)
+        if table is None:
+            self._log_schema_introspect(driver, schema_name=schema_name, table_name=None, operation="foreign_keys")
+            return driver.select(
+                self.get_query("foreign_keys_by_schema"), schema_name=schema_name, schema_type=ForeignKeyMetadata
+            )
+
+        self._log_table_describe(driver, schema_name=schema_name, table_name=table, operation="foreign_keys")
+        return driver.select(
+            self.get_query("foreign_keys_by_table"),
+            table_name=table,
+            schema_name=schema_name,
+            schema_type=ForeignKeyMetadata,
+        )

sqlspec/adapters/pymysql/driver.py

@@ -0,0 +1,271 @@
+"""PyMySQL MySQL driver implementation."""
+
+from collections.abc import Sized
+from typing import TYPE_CHECKING, Any, Final, cast
+
+import pymysql
+from pymysql.constants import FIELD_TYPE
+
+from sqlspec.adapters.pymysql._typing import PyMysqlCursor, PyMysqlSessionContext
+from sqlspec.adapters.pymysql.core import (
+    build_insert_statement,
+    collect_rows,
+    create_mapped_exception,
+    default_statement_config,
+    detect_json_columns_from_description,
+    driver_profile,
+    format_identifier,
+    normalize_execute_many_parameters,
+    normalize_execute_parameters,
+    normalize_lastrowid,
+    resolve_column_names,
+    resolve_many_rowcount,
+    resolve_rowcount,
+)
+from sqlspec.adapters.pymysql.data_dictionary import PyMysqlDataDictionary
+from sqlspec.core import ArrowResult, get_cache_config, register_driver_profile
+from sqlspec.driver import BaseSyncExceptionHandler, SyncDriverAdapterBase
+from sqlspec.exceptions import SQLSpecError
+from sqlspec.utils.logging import get_logger
+from sqlspec.utils.serializers import from_json
+from sqlspec.utils.type_guards import supports_json_type
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from sqlspec.adapters.pymysql._typing import PyMysqlConnection
+    from sqlspec.core import SQL, StatementConfig
+    from sqlspec.driver import ExecutionResult
+    from sqlspec.storage import StorageBridgeJob, StorageDestination, StorageFormat, StorageTelemetry
+
+__all__ = ("PyMysqlCursor", "PyMysqlDriver", "PyMysqlExceptionHandler", "PyMysqlSessionContext")
+
+logger = get_logger("sqlspec.adapters.pymysql")
+
+json_type_value = FIELD_TYPE.JSON if supports_json_type(FIELD_TYPE) else None
+PYMYSQL_JSON_TYPE_CODES: Final[set[int]] = {json_type_value} if json_type_value is not None else set()
+
+
+class PyMysqlExceptionHandler(BaseSyncExceptionHandler):
+    """Context manager for handling PyMySQL exceptions."""
+
+    __slots__ = ()
+
+    def _handle_exception(self, exc_type: "type[BaseException] | None", exc_val: "BaseException") -> bool:
+        if exc_type is None:
+            return False
+        if issubclass(exc_type, pymysql.MySQLError):
+            result = create_mapped_exception(exc_val, logger=logger)
+            if result is True:
+                return True
+            self.pending_exception = cast("Exception", result)
+            return True
+        return False
+
+
+class PyMysqlDriver(SyncDriverAdapterBase):
+    """MySQL/MariaDB database driver using PyMySQL."""
+
+    __slots__ = ("_data_dictionary",)
+    dialect = "mysql"
+
+    def __init__(
+        self,
+        connection: "PyMysqlConnection",
+        statement_config: "StatementConfig | None" = None,
+        driver_features: "dict[str, Any] | None" = None,
+    ) -> None:
+        if statement_config is None:
+            statement_config = default_statement_config.replace(
+                enable_caching=get_cache_config().compiled_cache_enabled
+            )
+
+        super().__init__(connection=connection, statement_config=statement_config, driver_features=driver_features)
+        self._data_dictionary: PyMysqlDataDictionary | None = None
+
+    def dispatch_execute(self, cursor: Any, statement: "SQL") -> "ExecutionResult":
+        sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
+        cursor.execute(sql, normalize_execute_parameters(prepared_parameters))
+
+        if statement.returns_rows():
+            fetched_data = cursor.fetchall()
+            description = cursor.description or None
+            column_names = resolve_column_names(description)
+            json_indexes = detect_json_columns_from_description(description, PYMYSQL_JSON_TYPE_CODES)
+            deserializer = cast("Callable[[Any], Any]", self.driver_features.get("json_deserializer", from_json))
+            rows, column_names, row_format = collect_rows(
+                fetched_data, description, json_indexes, deserializer, column_names=column_names, logger=logger
+            )
+
+            return self.create_execution_result(
+                cursor,
+                selected_data=rows,
+                column_names=column_names,
+                data_row_count=len(rows),
+                is_select_result=True,
+                row_format=row_format,
+            )
+
+        affected_rows = resolve_rowcount(cursor)
+        last_id = normalize_lastrowid(cursor)
+        return self.create_execution_result(cursor, rowcount_override=affected_rows, last_inserted_id=last_id)
+
+    def dispatch_execute_many(self, cursor: Any, statement: "SQL") -> "ExecutionResult":
+        sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
+
+        prepared_parameters = normalize_execute_many_parameters(prepared_parameters)
+        parameter_count = len(prepared_parameters) if isinstance(prepared_parameters, Sized) else None
+        cursor.executemany(sql, prepared_parameters)
+
+        affected_rows = resolve_many_rowcount(cursor, prepared_parameters, fallback_count=parameter_count)
+        return self.create_execution_result(cursor, rowcount_override=affected_rows, is_many_result=True)
+
+    def dispatch_execute_script(self, cursor: Any, statement: "SQL") -> "ExecutionResult":
+        sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
+        statements = self.split_script_statements(sql, statement.statement_config, strip_trailing_semicolon=True)
+
+        successful_count = 0
+        last_cursor = cursor
+
+        for stmt in statements:
+            cursor.execute(stmt, normalize_execute_parameters(prepared_parameters))
+            successful_count += 1
+
+        return self.create_execution_result(
+            last_cursor, statement_count=len(statements), successful_statements=successful_count, is_script_result=True
+        )
+
+    def begin(self) -> None:
+        try:
+            with PyMysqlCursor(self.connection) as cursor:
+                cursor.execute("BEGIN")
+        except pymysql.MySQLError as exc:
+            msg = f"Failed to begin MySQL transaction: {exc}"
+            raise SQLSpecError(msg) from exc
+
+    def commit(self) -> None:
+        try:
+            self.connection.commit()
+        except pymysql.MySQLError as exc:
+            msg = f"Failed to commit MySQL transaction: {exc}"
+            raise SQLSpecError(msg) from exc
+
+    def rollback(self) -> None:
+        try:
+            self.connection.rollback()
+        except pymysql.MySQLError as exc:
+            msg = f"Failed to rollback MySQL transaction: {exc}"
+            raise SQLSpecError(msg) from exc
+
+    def with_cursor(self, connection: "PyMysqlConnection") -> "PyMysqlCursor":
+        return PyMysqlCursor(connection)
+
+    def handle_database_exceptions(self) -> "PyMysqlExceptionHandler":
+        return PyMysqlExceptionHandler()
+
+    def select_to_storage(
+        self,
+        statement: "SQL | str",
+        destination: "StorageDestination",
+        /,
+        *parameters: Any,
+        statement_config: "StatementConfig | None" = None,
+        partitioner: "dict[str, object] | None" = None,
+        format_hint: "StorageFormat | None" = None,
+        telemetry: "StorageTelemetry | None" = None,
+        **kwargs: Any,
+    ) -> "StorageBridgeJob":
+        self._require_capability("arrow_export_enabled")
+        arrow_result = self.select_to_arrow(statement, *parameters, statement_config=statement_config, **kwargs)
+        pipeline = self._storage_pipeline()
+        telemetry_payload = self._write_result_to_storage_sync(
+            arrow_result, destination, format_hint=format_hint, pipeline=pipeline
+        )
+        self._attach_partition_telemetry(telemetry_payload, partitioner)
+        return self._create_storage_job(telemetry_payload, telemetry)
+
+    def load_from_arrow(
+        self,
+        table: str,
+        source: "ArrowResult | Any",
+        *,
+        partitioner: "dict[str, object] | None" = None,
+        overwrite: bool = False,
+        telemetry: "StorageTelemetry | None" = None,
+    ) -> "StorageBridgeJob":
+        self._require_capability("arrow_import_enabled")
+        arrow_table = self._coerce_arrow_table(source)
+        if overwrite:
+            statement = f"TRUNCATE TABLE {format_identifier(table)}"
+            exc_handler = self.handle_database_exceptions()
+            with exc_handler, self.with_cursor(self.connection) as cursor:
+                cursor.execute(statement)
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
+
+        columns, records = self._arrow_table_to_rows(arrow_table)
+        if records:
+            insert_sql = build_insert_statement(table, columns)
+            prepared_records = (
+                self.prepare_driver_parameters(records, self.statement_config, is_many=True)
+                if self._arrow_table_needs_parameter_preparation(arrow_table)
+                else records
+            )
+            exc_handler = self.handle_database_exceptions()
+            with exc_handler, self.with_cursor(self.connection) as cursor:
+                cursor.executemany(insert_sql, cast("Any", prepared_records))
+            if exc_handler.pending_exception is not None:
+                raise exc_handler.pending_exception from None
+
+        telemetry_payload = self._build_ingest_telemetry(arrow_table)
+        telemetry_payload["destination"] = table
+        self._attach_partition_telemetry(telemetry_payload, partitioner)
+        return self._create_storage_job(telemetry_payload, telemetry)
+
+    def load_from_storage(
+        self,
+        table: str,
+        source: "StorageDestination",
+        *,
+        file_format: "StorageFormat",
+        partitioner: "dict[str, object] | None" = None,
+        overwrite: bool = False,
+    ) -> "StorageBridgeJob":
+        arrow_table, inbound = self._read_arrow_from_storage_sync(source, file_format=file_format)
+        return self.load_from_arrow(table, arrow_table, partitioner=partitioner, overwrite=overwrite, telemetry=inbound)
+
+    @property
+    def data_dictionary(self) -> "PyMysqlDataDictionary":
+        if self._data_dictionary is None:
+            self._data_dictionary = PyMysqlDataDictionary()
+        return self._data_dictionary
+
+    def collect_rows(self, cursor: Any, fetched: "list[Any]") -> "tuple[list[Any], list[str], int]":
+        """Collect PyMySQL rows for the direct execution path."""
+        description = cursor.description or None
+        column_names = resolve_column_names(description)
+        json_indexes = detect_json_columns_from_description(description, PYMYSQL_JSON_TYPE_CODES)
+        deserializer = cast("Callable[[Any], Any]", self.driver_features.get("json_deserializer", from_json))
+        rows, column_names, _row_format = collect_rows(
+            fetched, description, json_indexes, deserializer, column_names=column_names, logger=logger
+        )
+        return rows, column_names, len(rows)
+
+    def resolve_rowcount(self, cursor: Any) -> int:
+        """Resolve rowcount from PyMySQL cursor for the direct execution path."""
+        return resolve_rowcount(cursor)
+
+    def _connection_in_transaction(self) -> bool:
+        get_autocommit = getattr(self.connection, "get_autocommit", None)
+        if callable(get_autocommit):
+            return not bool(get_autocommit())
+        autocommit = getattr(self.connection, "autocommit", None)
+        if autocommit is not None:
+            try:
+                return not bool(autocommit)
+            except Exception:
+                return False
+        return False
+
+
+register_driver_profile("pymysql", driver_profile)

sqlspec/adapters/pymysql/events/__init__.py

@@ -0,0 +1,5 @@
+"""Events helpers for the PyMySQL adapter."""
+
+from sqlspec.adapters.pymysql.events.store import PyMysqlEventQueueStore
+
+__all__ = ("PyMysqlEventQueueStore",)

sqlspec/adapters/pymysql/events/store.py

@@ -0,0 +1,50 @@
+"""PyMySQL event queue store with MySQL-specific DDL."""
+
+from typing import Final
+
+from sqlspec.adapters.pymysql.config import PyMysqlConfig
+from sqlspec.extensions.events import BaseEventQueueStore
+
+__all__ = ("PyMysqlEventQueueStore",)
+
+SCHEMA_QUALIFIED_SEGMENTS: Final[int] = 2
+
+
+class PyMysqlEventQueueStore(BaseEventQueueStore[PyMysqlConfig]):
+    """Queue DDL for PyMySQL configs."""
+
+    __slots__ = ()
+
+    def _column_types(self) -> "tuple[str, str, str]":
+        return "JSON", "JSON", "DATETIME(6)"
+
+    def _timestamp_default(self) -> str:
+        return "CURRENT_TIMESTAMP(6)"
+
+    def _build_index_sql(self) -> str | None:
+        table_name = self.table_name
+        segments = table_name.split(".", 1)
+
+        if len(segments) == SCHEMA_QUALIFIED_SEGMENTS:
+            schema = segments[0]
+            table = segments[1]
+            schema_selector = f"'{schema}'"
+        else:
+            table = segments[0]
+            schema_selector = "DATABASE()"
+
+        index_name = self._index_name()
+
+        return (
+            "SET @sqlspec_events_idx_exists := ("
+            "SELECT COUNT(1) FROM information_schema.statistics "
+            f"WHERE table_schema = {schema_selector} "
+            f"AND table_name = '{table}' "
+            f"AND index_name = '{index_name}');"
+            "SET @sqlspec_events_idx_stmt := IF(@sqlspec_events_idx_exists = 0, "
+            f"'ALTER TABLE {table_name} ADD INDEX {index_name} (channel, status, available_at)', "
+            "'SELECT 1');"
+            "PREPARE sqlspec_events_stmt FROM @sqlspec_events_idx_stmt;"
+            "EXECUTE sqlspec_events_stmt;"
+            "DEALLOCATE PREPARE sqlspec_events_stmt;"
+        )

sqlspec/adapters/pymysql/litestar/__init__.py

@@ -0,0 +1,5 @@
+"""Litestar helpers for the PyMySQL adapter."""
+
+from sqlspec.adapters.pymysql.litestar.store import PyMysqlStore
+
+__all__ = ("PyMysqlStore",)

sqlspec/adapters/pymysql/litestar/store.py

@@ -0,0 +1,232 @@
+"""PyMySQL session store for Litestar integration."""
+
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING, Final
+
+import pymysql
+
+from sqlspec.extensions.litestar.store import BaseSQLSpecStore
+from sqlspec.utils.logging import get_logger
+from sqlspec.utils.sync_tools import async_
+
+if TYPE_CHECKING:
+    from sqlspec.adapters.pymysql.config import PyMysqlConfig
+
+logger = get_logger("sqlspec.adapters.pymysql.litestar.store")
+
+__all__ = ("PyMysqlStore",)
+
+MYSQL_TABLE_NOT_FOUND_ERROR: Final = 1146
+
+
+class PyMysqlStore(BaseSQLSpecStore["PyMysqlConfig"]):
+    """MySQL/MariaDB session store using PyMySQL sync driver."""
+
+    __slots__ = ()
+
+    def __init__(self, config: "PyMysqlConfig") -> None:
+        super().__init__(config)
+
+    def _get_create_table_sql(self) -> str:
+        return f"""
+        CREATE TABLE IF NOT EXISTS {self._table_name} (
+            session_id VARCHAR(255) PRIMARY KEY,
+            data LONGBLOB NOT NULL,
+            expires_at DATETIME(6),
+            created_at DATETIME(6) DEFAULT CURRENT_TIMESTAMP(6),
+            updated_at DATETIME(6) DEFAULT CURRENT_TIMESTAMP(6) ON UPDATE CURRENT_TIMESTAMP(6),
+            INDEX idx_{self._table_name}_expires_at (expires_at)
+        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+        """
+
+    def _get_drop_table_sql(self) -> "list[str]":
+        return [
+            f"DROP INDEX idx_{self._table_name}_expires_at ON {self._table_name}",
+            f"DROP TABLE IF EXISTS {self._table_name}",
+        ]
+
+    def _create_table(self) -> None:
+        sql = self._get_create_table_sql()
+        with self._config.provide_session() as driver:
+            driver.execute_script(sql)
+            driver.commit()
+        self._log_table_created()
+
+    async def create_table(self) -> None:
+        await async_(self._create_table)()
+
+    def _get(self, key: str, renew_for: "int | timedelta | None" = None) -> "bytes | None":
+        sql = f"""
+        SELECT data, expires_at FROM {self._table_name}
+        WHERE session_id = %s
+        AND (expires_at IS NULL OR expires_at > UTC_TIMESTAMP(6))
+        """
+
+        try:
+            with self._config.provide_connection() as conn:
+                cursor = conn.cursor(pymysql.cursors.DictCursor)
+                try:
+                    cursor.execute(sql, (key,))
+                    row = cursor.fetchone()
+                finally:
+                    cursor.close()
+
+                if row is None:
+                    return None
+
+                if renew_for is not None and row["expires_at"] is not None:
+                    new_expires_at = self._calculate_expires_at(renew_for)
+                    if new_expires_at is not None:
+                        naive_expires_at = new_expires_at.replace(tzinfo=None)
+                        update_sql = f"""
+                        UPDATE {self._table_name}
+                        SET expires_at = %s, updated_at = UTC_TIMESTAMP(6)
+                        WHERE session_id = %s
+                        """
+                        update_cursor = conn.cursor()
+                        try:
+                            update_cursor.execute(update_sql, (naive_expires_at, key))
+                        finally:
+                            update_cursor.close()
+                        conn.commit()
+
+                return bytes(row["data"])
+        except pymysql.MySQLError as exc:
+            if "doesn't exist" in str(exc) or getattr(exc, "args", [None])[0] == MYSQL_TABLE_NOT_FOUND_ERROR:
+                return None
+            raise
+
+    async def get(self, key: str, renew_for: "int | timedelta | None" = None) -> "bytes | None":
+        return await async_(self._get)(key, renew_for)
+
+    def _set(self, key: str, value: "str | bytes", expires_in: "int | timedelta | None" = None) -> None:
+        data = self._value_to_bytes(value)
+        expires_at = self._calculate_expires_at(expires_in)
+        naive_expires_at = expires_at.replace(tzinfo=None) if expires_at else None
+
+        sql = f"""
+        INSERT INTO {self._table_name} (session_id, data, expires_at)
+        VALUES (%s, %s, %s) AS new
+        ON DUPLICATE KEY UPDATE
+            data = new.data,
+            expires_at = new.expires_at,
+            updated_at = UTC_TIMESTAMP(6)
+        """
+
+        with self._config.provide_connection() as conn:
+            cursor = conn.cursor()
+            try:
+                cursor.execute(sql, (key, data, naive_expires_at))
+            finally:
+                cursor.close()
+            conn.commit()
+
+    async def set(self, key: str, value: "str | bytes", expires_in: "int | timedelta | None" = None) -> None:
+        await async_(self._set)(key, value, expires_in)
+
+    def _delete(self, key: str) -> None:
+        sql = f"DELETE FROM {self._table_name} WHERE session_id = %s"
+
+        with self._config.provide_connection() as conn:
+            cursor = conn.cursor()
+            try:
+                cursor.execute(sql, (key,))
+            finally:
+                cursor.close()
+            conn.commit()
+
+    async def delete(self, key: str) -> None:
+        await async_(self._delete)(key)
+
+    def _delete_all(self) -> None:
+        sql = f"DELETE FROM {self._table_name}"
+
+        try:
+            with self._config.provide_connection() as conn:
+                cursor = conn.cursor()
+                try:
+                    cursor.execute(sql)
+                finally:
+                    cursor.close()
+                conn.commit()
+            self._log_delete_all()
+        except pymysql.MySQLError as exc:
+            if "doesn't exist" in str(exc) or getattr(exc, "args", [None])[0] == MYSQL_TABLE_NOT_FOUND_ERROR:
+                logger.debug("Table %s does not exist, skipping delete_all", self._table_name)
+                return
+            raise
+
+    async def delete_all(self) -> None:
+        await async_(self._delete_all)()
+
+    def _exists(self, key: str) -> bool:
+        sql = f"""
+        SELECT 1 FROM {self._table_name}
+        WHERE session_id = %s
+        AND (expires_at IS NULL OR expires_at > UTC_TIMESTAMP(6))
+        """
+
+        try:
+            with self._config.provide_connection() as conn:
+                cursor = conn.cursor()
+                try:
+                    cursor.execute(sql, (key,))
+                    result = cursor.fetchone()
+                finally:
+                    cursor.close()
+                return result is not None
+        except pymysql.MySQLError as exc:
+            if "doesn't exist" in str(exc) or getattr(exc, "args", [None])[0] == MYSQL_TABLE_NOT_FOUND_ERROR:
+                return False
+            raise
+
+    async def exists(self, key: str) -> bool:
+        return await async_(self._exists)(key)
+
+    def _expires_in(self, key: str) -> "int | None":
+        sql = f"""
+        SELECT expires_at FROM {self._table_name}
+        WHERE session_id = %s
+        """
+
+        with self._config.provide_connection() as conn:
+            cursor = conn.cursor()
+            try:
+                cursor.execute(sql, (key,))
+                row = cursor.fetchone()
+            finally:
+                cursor.close()
+
+            if row is None or row[0] is None:
+                return None
+
+            expires_at_naive = row[0]
+            expires_at_utc = expires_at_naive.replace(tzinfo=timezone.utc)
+            now = datetime.now(timezone.utc)
+
+            if expires_at_utc <= now:
+                return 0
+
+            delta = expires_at_utc - now
+            return int(delta.total_seconds())
+
+    async def expires_in(self, key: str) -> "int | None":
+        return await async_(self._expires_in)(key)
+
+    def _delete_expired(self) -> int:
+        sql = f"DELETE FROM {self._table_name} WHERE expires_at <= UTC_TIMESTAMP(6)"
+
+        with self._config.provide_connection() as conn:
+            cursor = conn.cursor()
+            try:
+                cursor.execute(sql)
+                conn.commit()
+                count: int = cursor.rowcount
+            finally:
+                cursor.close()
+            if count > 0:
+                self._log_delete_expired(count)
+            return count
+
+    async def delete_expired(self) -> int:
+        return await async_(self._delete_expired)()