sqlspec 0.58.2__tar.gz → 0.58.3__tar.gz

{sqlspec-0.58.2 → sqlspec-0.58.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.58.2
+Version: 0.58.3
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/

{sqlspec-0.58.2 → sqlspec-0.58.3}/pyproject.toml

@@ -24,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.58.2"
+version = "0.58.3"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -331,7 +331,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.58.2"
+current_version = "0.58.3"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.58.2 → sqlspec-0.58.3}/sqlspec/extensions/litestar/store.py

@@ -1,9 +1,11 @@
 """Base session store classes for Litestar integration."""
 
 import re
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 from datetime import datetime, timedelta, timezone
-from typing import TYPE_CHECKING, Any, ClassVar, Final, Generic, TypeVar, cast
+from typing import Any, ClassVar, Final, Generic, TypeVar, cast
+
+from litestar.stores.base import Store
 
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.migrations.schema import SchemaTarget, ensure_schema_async, ensure_schema_sync
@@ -12,11 +14,6 @@ from sqlspec.utils.logging import get_logger
 from sqlspec.utils.sync_tools import async_
 from sqlspec.utils.type_guards import has_extension_config
 
-if TYPE_CHECKING:
-    from types import TracebackType
-
-    from typing_extensions import Self
-
 __all__ = ("BaseSQLSpecStore",)
 
 
@@ -30,11 +27,11 @@ VALID_TABLE_NAME_PATTERN: Final = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
 MAX_TABLE_NAME_LENGTH: Final = 63
 
 
-class BaseSQLSpecStore(ABC, Generic[ConfigT]):
+class BaseSQLSpecStore(Store, Generic[ConfigT]):
     """Base class for SQLSpec-backed Litestar session stores.
 
-    Implements the litestar.stores.base.Store protocol for server-side session
-    storage using SQLSpec database adapters.
+    Inherits Litestar's ``Store`` abstract base class for server-side session
+    storage backed by SQLSpec database adapters.
 
     This abstract base class provides common functionality for all database-specific
     store implementations including:
@@ -81,16 +78,6 @@ class BaseSQLSpecStore(ABC, Generic[ConfigT]):
         self._table_name = self._table_name_from_config()
         self._ensure_table_name(self._table_name)
 
-    async def __aenter__(self) -> "Self":
-        """Enter context manager."""
-        return self
-
-    async def __aexit__(
-        self, exc_type: "type[BaseException] | None", exc_val: "BaseException | None", exc_tb: "TracebackType | None"
-    ) -> None:
-        """Exit context manager."""
-        return
-
     @property
     def config(self) -> ConfigT:
         """Return the database configuration."""
@@ -107,70 +94,6 @@ class BaseSQLSpecStore(ABC, Generic[ConfigT]):
         manage_schema, create_schema = self._schema_management_flags()
         return manage_schema and create_schema
 
-    @abstractmethod
-    async def get(self, key: str, renew_for: "int | timedelta | None" = None) -> "bytes | None":
-        """Get a session value by key.
-
-        Args:
-            key: Session ID to retrieve.
-            renew_for: If given and the value had an initial expiry time set, renew the
-                expiry time for ``renew_for`` seconds. If the value has not been set
-                with an expiry time this is a no-op.
-
-        Returns:
-            Session data as bytes if found and not expired, None otherwise.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    async def set(self, key: str, value: "str | bytes", expires_in: "int | timedelta | None" = None) -> None:
-        """Store a session value.
-
-        Args:
-            key: Session ID.
-            value: Session data (will be converted to bytes if string).
-            expires_in: Time in seconds or timedelta before expiration.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    async def delete(self, key: str) -> None:
-        """Delete a session by key.
-
-        Args:
-            key: Session ID to delete.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    async def delete_all(self) -> None:
-        """Delete all sessions from the store."""
-        raise NotImplementedError
-
-    @abstractmethod
-    async def exists(self, key: str) -> bool:
-        """Check if a session key exists and is not expired.
-
-        Args:
-            key: Session ID to check.
-
-        Returns:
-            True if the session exists and is not expired.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    async def expires_in(self, key: str) -> "int | None":
-        """Get the time in seconds until the session expires.
-
-        Args:
-            key: Session ID to check.
-
-        Returns:
-            Seconds until expiration, or None if no expiry or key doesn't exist.
-        """
-        raise NotImplementedError
-
     @abstractmethod
     async def delete_expired(self) -> int:
         """Delete all expired sessions.

{sqlspec-0.58.2 → sqlspec-0.58.3}/sqlspec/migrations/runner.py

@@ -87,6 +87,7 @@ class BaseMigrationRunner:
         self.extension_migrations = extension_migrations or {}
         self.runtime = runtime
         self.loader = SQLFileLoader(runtime=runtime)
+        self._extension_sql_loaders: dict[str, SQLFileLoader] = {}
         self.project_root: Path | None = None
         self.context = context
         self.extension_configs = extension_configs or {}
@@ -618,6 +619,22 @@ class BaseMigrationRunner:
             return cast("list[str]", sql_statements)
         return None
 
+    def _migration_sql_loader(self, file_path: Path, version: "str | None") -> SQLFileLoader:
+        """Return the isolated core SQL loader for an extension migration."""
+        extension = parse_extension_stem(version) if version else None
+        if file_path.suffix != ".sql" or extension is None:
+            return self.loader
+
+        extension_name, _ = extension
+        if self.extension_migrations.get(extension_name) != file_path.parent:
+            return self.loader
+
+        loader = self._extension_sql_loaders.get(extension_name)
+        if loader is None:
+            loader = SQLFileLoader(runtime=self.runtime)
+            self._extension_sql_loaders[extension_name] = loader
+        return loader
+
 
 class SyncMigrationRunner(BaseMigrationRunner):
     """Synchronous migration runner with pure sync methods."""
@@ -643,15 +660,16 @@ class SyncMigrationRunner(BaseMigrationRunner):
         metadata = self._load_metadata(file_path, version)
         context_to_use = self._migration_context(file_path)
 
-        loader = get_migration_loader(file_path, self.migrations_path, self.project_root, context_to_use, self.loader)
+        sql_loader = self._migration_sql_loader(file_path, metadata["version"])
+        loader = get_migration_loader(file_path, self.migrations_path, self.project_root, context_to_use, sql_loader)
         loader.validate_migration_file(file_path)
 
         has_upgrade, has_downgrade = True, False
 
         if file_path.suffix == ".sql":
-            version = metadata["version"]
-            up_query, down_query = f"migrate-{version}-up", f"migrate-{version}-down"
-            has_upgrade, has_downgrade = self.loader.has_query(up_query), self.loader.has_query(down_query)
+            partial = cast("LoadedMigrationMetadata", {"loader": loader, "file_path": file_path})
+            has_upgrade = bool(self._migration_sql(partial, "up"))
+            has_downgrade = bool(self._migration_sql(partial, "down"))
         else:
             try:
                 partial = cast("LoadedMigrationMetadata", {"loader": loader, "file_path": file_path})
@@ -827,6 +845,15 @@ class SyncMigrationRunner(BaseMigrationRunner):
 
         for version, file_path in migrations:
             if file_path.suffix == ".sql":
+                if self._migration_sql_loader(file_path, version) is not self.loader:
+                    migration = self.load_migration(file_path, version)
+                    up_sql = self._migration_sql(migration, "up")
+                    down_sql = self._migration_sql(migration, "down")
+                    if up_sql:
+                        all_queries[f"migrate-{version}-up"] = SQL(up_sql[0])
+                    if down_sql:
+                        all_queries[f"migrate-{version}-down"] = SQL(down_sql[0])
+                    continue
                 if not self.loader.has_query(f"migrate-{version}-up"):
                     self.loader.load_sql(file_path)
                 for query_name in self.loader.list_queries():
@@ -877,15 +904,16 @@ class AsyncMigrationRunner(BaseMigrationRunner):
         metadata = self._load_metadata(file_path, version)
         context_to_use = self._migration_context(file_path)
 
-        loader = get_migration_loader(file_path, self.migrations_path, self.project_root, context_to_use, self.loader)
+        sql_loader = self._migration_sql_loader(file_path, metadata["version"])
+        loader = get_migration_loader(file_path, self.migrations_path, self.project_root, context_to_use, sql_loader)
         loader.validate_migration_file(file_path)
 
         has_upgrade, has_downgrade = True, False
 
         if file_path.suffix == ".sql":
-            version = metadata["version"]
-            up_query, down_query = f"migrate-{version}-up", f"migrate-{version}-down"
-            has_upgrade, has_downgrade = self.loader.has_query(up_query), self.loader.has_query(down_query)
+            partial = cast("LoadedMigrationMetadata", {"loader": loader, "file_path": file_path})
+            has_upgrade = bool(await self._migration_sql(partial, "up"))
+            has_downgrade = bool(await self._migration_sql(partial, "down"))
         else:
             try:
                 partial = cast("LoadedMigrationMetadata", {"loader": loader, "file_path": file_path})
@@ -1062,6 +1090,15 @@ class AsyncMigrationRunner(BaseMigrationRunner):
 
         for version, file_path in migrations:
             if file_path.suffix == ".sql":
+                if self._migration_sql_loader(file_path, version) is not self.loader:
+                    migration = await self.load_migration(file_path, version)
+                    up_sql = await self._migration_sql(migration, "up")
+                    down_sql = await self._migration_sql(migration, "down")
+                    if up_sql:
+                        all_queries[f"migrate-{version}-up"] = SQL(up_sql[0])
+                    if down_sql:
+                        all_queries[f"migrate-{version}-down"] = SQL(down_sql[0])
+                    continue
                 if not self.loader.has_query(f"migrate-{version}-up"):
                     await async_(self.loader.load_sql)(file_path)
                 for query_name in self.loader.list_queries():

{sqlspec-0.58.2 → sqlspec-0.58.3}/sqlspec/utils/schema.py

@@ -1,12 +1,13 @@
 """Schema transformation utilities for converting data to various schema types."""
 
 import datetime
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from decimal import Decimal, InvalidOperation
 from enum import Enum
 from functools import partial
 from pathlib import Path, PurePath
-from typing import Any, Final, TypeGuard, cast, overload
+from types import UnionType
+from typing import Annotated, Any, Final, TypeGuard, Union, cast, get_args, get_origin, overload
 from uuid import UUID
 
 from typing_extensions import TypeVar
@@ -15,12 +16,9 @@ from sqlspec.data_dictionary import ForeignKeyMetadata
 from sqlspec.exceptions import SQLSpecError
 from sqlspec.typing import CATTRS_INSTALLED, NUMPY_INSTALLED, MsgspecValidationError, SchemaT, convert, get_type_adapter
 from sqlspec.utils.dispatch import TypeDispatcher
-from sqlspec.utils.logging import get_logger
 from sqlspec.utils.module_loader import import_optional_attr
 from sqlspec.utils.serializers import from_json
-from sqlspec.utils.text import camelize, kebabize, pascalize
 from sqlspec.utils.type_guards import (
-    get_msgspec_rename_config,
     is_attrs_instance,
     is_attrs_schema,
     is_dataclass,
@@ -46,16 +44,12 @@ __all__ = (
 DataT = TypeVar("DataT", default=dict[str, Any])
 ValueT = TypeVar("ValueT")
 
-logger = get_logger(__name__)
-
 _DATETIME_TYPES: Final[set[type]] = {datetime.datetime, datetime.date, datetime.time}
 _DATETIME_TYPE_TUPLE: Final[tuple[type, ...]] = (datetime.datetime, datetime.date, datetime.time)
-_MSGSPEC_RENAME_CONVERTERS: Final[dict[str, Callable[[str], str]]] = {
-    "camel": camelize,
-    "kebab": kebabize,
-    "pascal": pascalize,
-}
+_MAPPING_TYPE_ARGUMENT_COUNT: Final = 2
+_MSGSPEC_FIELD_CACHE: "dict[type, tuple[tuple[tuple[str, str, Any], ...], frozenset[str], frozenset[str]]]" = {}
 _NUMPY_RECURSIVE_DISPATCHER: "TypeDispatcher[Callable[[Any], Any]] | None" = None
+_NULLABLE_UNION_ARGUMENT_COUNT: Final = 2
 
 
 # =============================================================================
@@ -356,20 +350,11 @@ def _get_numpy_recursive_dispatcher() -> "TypeDispatcher[Callable[[Any], Any]]":
 
 def _convert_msgspec(data: Any, schema_type: Any) -> Any:
     """Convert data to msgspec Struct."""
-    rename_config = get_msgspec_rename_config(schema_type)
-
-    transformed_data = data
-    if (rename_config and is_dict(data)) or (isinstance(data, Sequence) and data and is_dict(data[0])):
-        try:
-            converter = _MSGSPEC_RENAME_CONVERTERS.get(rename_config) if rename_config else None
-            if converter:
-                transformed_data = (
-                    [transform_dict_keys(item, converter) if is_dict(item) else item for item in data]
-                    if isinstance(data, Sequence)
-                    else (transform_dict_keys(data, converter) if is_dict(data) else data)
-                )
-        except Exception as e:
-            logger.debug("Field name transformation failed for msgspec schema: %s", e)
+    transformed_data = (
+        [_normalize_msgspec_input(item, schema_type) for item in data]
+        if isinstance(data, Sequence) and not isinstance(data, (str, bytes, bytearray))
+        else _normalize_msgspec_input(data, schema_type)
+    )
 
     target_type = list[schema_type] if isinstance(transformed_data, Sequence) else schema_type
 
@@ -386,6 +371,98 @@ def _convert_msgspec(data: Any, schema_type: Any) -> Any:
         )
 
 
+def _normalize_msgspec_input(data: Any, target_type: Any) -> Any:
+    """Normalize Struct field aliases according to the declared target type."""
+    target_type = _unwrap_msgspec_target(target_type)
+    if target_type is None:
+        return data
+
+    if is_msgspec_struct(target_type):
+        return _normalize_msgspec_struct(data, cast("type", target_type))
+
+    origin = get_origin(target_type)
+    args = get_args(target_type)
+    if origin is None or not args:
+        return data
+
+    if _is_mapping_origin(origin):
+        if not isinstance(data, Mapping) or len(args) < _MAPPING_TYPE_ARGUMENT_COUNT:
+            return data
+        value_type = args[1]
+        return {key: _normalize_msgspec_input(value, value_type) for key, value in data.items()}
+
+    if _is_sequence_origin(origin):
+        if not isinstance(data, Sequence) or isinstance(data, (str, bytes, bytearray)):
+            return data
+        if origin is tuple and len(args) > 1 and args[1] is not Ellipsis:
+            return [
+                _normalize_msgspec_input(value, args[index]) if index < len(args) else value
+                for index, value in enumerate(data)
+            ]
+        item_type = next(iter(args), Any)
+        return [_normalize_msgspec_input(value, item_type) for value in data]
+
+    return data
+
+
+def _normalize_msgspec_struct(data: Any, schema_type: type) -> Any:
+    if not isinstance(data, Mapping):
+        return data
+
+    fields, python_names, encoded_names = _msgspec_field_plan(schema_type)
+    normalized = {key: value for key, value in data.items() if key not in python_names and key not in encoded_names}
+
+    for name, encode_name, field_type in fields:
+        if encode_name in data:
+            normalized[encode_name] = _normalize_msgspec_input(data[encode_name], field_type)
+        elif name in data:
+            normalized[encode_name] = _normalize_msgspec_input(data[name], field_type)
+
+    return normalized
+
+
+def _msgspec_field_plan(schema_type: type) -> "tuple[tuple[tuple[str, str, Any], ...], frozenset[str], frozenset[str]]":
+    try:
+        return _MSGSPEC_FIELD_CACHE[schema_type]
+    except KeyError:
+        from msgspec import structs
+
+        fields = tuple(
+            (field.name, field.encode_name, field.type) for field in structs.fields(cast("Any", schema_type))
+        )
+        plan = fields, frozenset(field[0] for field in fields), frozenset(field[1] for field in fields)
+        _MSGSPEC_FIELD_CACHE[schema_type] = plan
+        return plan
+
+
+def _unwrap_msgspec_target(target_type: Any) -> Any:
+    while get_origin(target_type) is Annotated:
+        target_type = get_args(target_type)[0]
+
+    origin = get_origin(target_type)
+    if origin is Union or origin is UnionType:
+        args = get_args(target_type)
+        non_null = tuple(arg for arg in args if arg is not type(None))
+        if len(args) == _NULLABLE_UNION_ARGUMENT_COUNT and len(non_null) == 1:
+            return _unwrap_msgspec_target(non_null[0])
+        return None
+    return target_type
+
+
+def _is_mapping_origin(origin: Any) -> bool:
+    try:
+        return issubclass(origin, Mapping)
+    except TypeError:
+        return False
+
+
+def _is_sequence_origin(origin: Any) -> bool:
+    try:
+        return issubclass(origin, Sequence)
+    except TypeError:
+        return False
+
+
 def _convert_pydantic(data: Any, schema_type: Any) -> Any:
     """Convert data to Pydantic model."""
     if isinstance(data, Sequence):

{sqlspec-0.58.2 → sqlspec-0.58.3}/sqlspec/utils/sync_tools.py

@@ -15,7 +15,7 @@ import os
 import sys
 import threading
 from contextlib import AbstractAsyncContextManager, AbstractContextManager
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast, overload
 
 from typing_extensions import ParamSpec
 
@@ -301,9 +301,19 @@ def async_(
     return _AsyncWrapper(function, limiter, executor)
 
 
+@overload
+def ensure_async_(
+    function: "Callable[ParamSpecT, Awaitable[ReturnT]]",
+) -> "Callable[ParamSpecT, Coroutine[Any, Any, ReturnT]]": ...
+
+
+@overload
 def ensure_async_(
     function: "Callable[ParamSpecT, Awaitable[ReturnT] | ReturnT]",
-) -> "Callable[ParamSpecT, Awaitable[ReturnT]]":
+) -> "Callable[ParamSpecT, Coroutine[Any, Any, ReturnT]]": ...
+
+
+def ensure_async_(function: "Callable[ParamSpecT, Any]") -> "Callable[ParamSpecT, Coroutine[Any, Any, Any]]":
     """Convert a function to an async one if it is not already.
 
     Args:

{sqlspec-0.58.2 → sqlspec-0.58.3}/tests/integration/adapters/sqlite/sqlite/extensions/litestar/test_store.py

@@ -10,6 +10,8 @@ import asyncio
 from collections.abc import AsyncGenerator
 
 import pytest
+from litestar.stores.base import Store
+from litestar.stores.registry import StoreRegistry
 
 from sqlspec.adapters.sqlite.config import SqliteConfig
 from sqlspec.adapters.sqlite.litestar.store import SQLiteStore
@@ -46,3 +48,15 @@ async def test_sync_to_thread_concurrency(sqlite_store: SQLiteStore) -> None:
 
     for i, result in enumerate(results):
         assert result == f"data_{i}".encode()
+
+
+async def test_store_implements_litestar_store_contract(sqlite_store: SQLiteStore) -> None:
+    """SQLite stores satisfy Litestar's nominal store and registry contract."""
+    registry = StoreRegistry()
+
+    assert isinstance(sqlite_store, Store)
+    registry.register("sessions", sqlite_store)
+    assert registry.get("sessions") is sqlite_store
+
+    async with sqlite_store as value:
+        assert value is None

{sqlspec-0.58.2 → sqlspec-0.58.3}/tests/integration/migrations/test_upgrade_downgrade_versions.py

@@ -414,8 +414,8 @@ DROP TABLE {table_name};
 def test_upgrade_applies_third_party_extension_migrations(tmp_path: Path) -> None:
     """A package outside sqlspec.extensions applies migrations through the public API.
 
-    Covers both extension migration layouts: a file inside the extension's own directory,
-    and an ``ext_``-prefixed file sitting in the main migrations directory.
+    Covers Python and SQL files inside the extension's own directory and an
+    ``ext_``-prefixed SQL file sitting in the main migrations directory.
     """
     migrations_dir = tmp_path / "migrations"
     migrations_dir.mkdir()
@@ -442,11 +442,19 @@ def down(context: "object | None" = None) -> "list[str]":
     """Return the downgrade statements."""
     return ["DROP TABLE queue_tasks"]
 ''')
-    (migrations_dir / "ext_litestar_queues_0002_add_index.sql").write_text(
-        """-- name: migrate-ext_litestar_queues_0002-up
+    (vendor_dir / "0002_create_queue_metadata.sql").write_text(
+        """-- name: migrate-0002-up
+CREATE TABLE queue_metadata (id INTEGER PRIMARY KEY);
+
+-- name: migrate-0002-down
+DROP TABLE queue_metadata;
+"""
+    )
+    (migrations_dir / "ext_litestar_queues_0003_add_index.sql").write_text(
+        """-- name: migrate-ext_litestar_queues_0003-up
 CREATE INDEX queue_tasks_id_idx ON queue_tasks (id);
 
--- name: migrate-ext_litestar_queues_0002-down
+-- name: migrate-ext_litestar_queues_0003-down
 DROP INDEX queue_tasks_id_idx;
 """
     )
@@ -466,8 +474,10 @@ DROP INDEX queue_tasks_id_idx;
             tables = session.execute("SELECT name FROM sqlite_master WHERE type = 'table'").get_data()
 
         versions = [row["version_num"] for row in applied]
-        assert versions == ["0001", "ext_litestar_queues_0001", "ext_litestar_queues_0002"]
-        assert "queue_tasks" in {row["name"] for row in tables}
+        assert versions == ["0001", "ext_litestar_queues_0001", "ext_litestar_queues_0002", "ext_litestar_queues_0003"]
+        table_names = {row["name"] for row in tables}
+        assert "queue_tasks" in table_names
+        assert "queue_metadata" in table_names
 
         commands.downgrade(revision="base")
         assert commands.current() is None

{sqlspec-0.58.2 → sqlspec-0.58.3}/tests/unit/adapters/test_aiomysql/test_load_from_arrow.py

@@ -7,7 +7,6 @@ import anyio
 import pyarrow as pa
 import pyarrow.parquet as pq
 
-from sqlspec.adapters.aiomysql.core import build_insert_statement
 from sqlspec.adapters.aiomysql.driver import AiomysqlDriver
 
 _CAPS: dict[str, Any] = {
@@ -91,12 +90,6 @@ async def test_load_from_arrow_overwrite_truncates_first() -> None:
     assert any(sql.startswith("LOAD DATA") for sql in conn._cursor.execute_calls)
 
 
-def test_build_insert_statement_preserves_backtick_quoted_dots() -> None:
-    statement = build_insert_statement("`analytics.db`.`orders.table`", ["id"])
-
-    assert statement == "INSERT INTO `analytics.db`.`orders.table` (`id`) VALUES (%s)"
-
-
 async def test_load_from_storage_reads_parquet_and_delegates(tmp_path: Path) -> None:
     parquet_path = tmp_path / "data.parquet"
     pq.write_table(pa.table({"id": [1, 2], "name": ["a", "b"]}), parquet_path)

{sqlspec-0.58.2 → sqlspec-0.58.3}/tests/unit/adapters/test_async_adapters.py

@@ -233,14 +233,6 @@ async def test_async_driver_dispatch_statement_execution_many(aiosqlite_async_dr
 
 
 async def test_async_dispatch_no_dead_processed_state_cast(aiosqlite_async_driver: AiosqliteDriver) -> None:
-    """Async dispatch should not contain the removed get_processed_state cast."""
-    import inspect
-
-    from sqlspec.driver import _async as async_module
-
-    source = inspect.getsource(async_module.AsyncDriverAdapterBase.dispatch_statement_execution)
-    assert "get_processed_state" not in source
-
     statement = SQL("SELECT * FROM users", statement_config=aiosqlite_async_driver.statement_config)
     result = await aiosqlite_async_driver.dispatch_statement_execution(statement, aiosqlite_async_driver.connection)
 
@@ -248,14 +240,6 @@ async def test_async_dispatch_no_dead_processed_state_cast(aiosqlite_async_drive
     assert result.operation_type == "SELECT"
 
 
-def test_async_import_structure() -> None:
-    """ProcessedState and Statement are not runtime names in _async.py."""
-    from sqlspec.driver import _async as async_module
-
-    assert not hasattr(async_module, "ProcessedState")
-    assert not hasattr(async_module, "Statement")
-
-
 async def test_async_driver_releases_pooled_statement(aiosqlite_async_driver: AiosqliteDriver) -> None:
     """Pooled statements should be reset after dispatch execution."""
     seed = "SELECT * FROM users WHERE id = ?"

{sqlspec-0.58.2 → sqlspec-0.58.3}/tests/unit/adapters/test_asyncmy/test_load_from_arrow.py

@@ -6,7 +6,6 @@ from typing import Any, cast
 import pyarrow as pa
 import pyarrow.parquet as pq
 
-from sqlspec.adapters.asyncmy.core import build_insert_statement
 from sqlspec.adapters.asyncmy.driver import AsyncmyDriver
 
 _CAPS: dict[str, Any] = {
@@ -71,12 +70,6 @@ async def test_load_from_arrow_overwrite_truncates_first() -> None:
     assert conn._cursor.executemany_calls[0][0].startswith("INSERT INTO")
 
 
-def test_build_insert_statement_preserves_backtick_quoted_dots() -> None:
-    statement = build_insert_statement("`analytics.db`.`orders.table`", ["id"])
-
-    assert statement == "INSERT INTO `analytics.db`.`orders.table` (`id`) VALUES (%s)"
-
-
 async def test_load_from_storage_reads_parquet_and_delegates(tmp_path: Path) -> None:
     parquet_path = tmp_path / "data.parquet"
     pq.write_table(pa.table({"id": [1, 2], "name": ["a", "b"]}), parquet_path)

{sqlspec-0.58.2 → sqlspec-0.58.3}/tests/unit/adapters/test_bigquery/test_core.py

@@ -215,12 +215,6 @@ def test_copy_job_fields_use_real_reservation_attribute() -> None:
     assert "reservation_id" not in _COPY_JOB_FIELDS
 
 
-def test_copy_job_attribute_helper_removed() -> None:
-    import sqlspec.adapters.bigquery.core as bigquery_core
-
-    assert not hasattr(bigquery_core, "_should_copy_job_attribute")
-
-
 def test_run_query_job_passes_query_start_retry_timeout_and_job_retry() -> None:
     connection = _RecordingConnection()
     retry = build_retry(1.0)

sqlspec-0.58.3/tests/unit/adapters/test_mysql_insert_statement_contract.py

@@ -0,0 +1,22 @@
+"""Shared MySQL-family insert-statement contracts."""
+
+from collections.abc import Callable
+
+import pytest
+
+from sqlspec.adapters.aiomysql.core import build_insert_statement as build_aiomysql_insert
+from sqlspec.adapters.asyncmy.core import build_insert_statement as build_asyncmy_insert
+from sqlspec.adapters.mysqlconnector.core import build_insert_statement as build_mysqlconnector_insert
+from sqlspec.adapters.pymysql.core import build_insert_statement as build_pymysql_insert
+
+
+@pytest.mark.parametrize(
+    "build_insert_statement",
+    (build_aiomysql_insert, build_asyncmy_insert, build_mysqlconnector_insert, build_pymysql_insert),
+)
+def test_build_insert_statement_preserves_backtick_quoted_dots(
+    build_insert_statement: Callable[[str, list[str]], str],
+) -> None:
+    statement = build_insert_statement("`analytics.db`.`orders.table`", ["id"])
+
+    assert statement == "INSERT INTO `analytics.db`.`orders.table` (`id`) VALUES (%s)"

{sqlspec-0.58.2 → sqlspec-0.58.3}/tests/unit/adapters/test_mysqlconnector/test_load_from_arrow.py

@@ -7,7 +7,6 @@ import anyio
 import pyarrow as pa
 import pyarrow.parquet as pq
 
-from sqlspec.adapters.mysqlconnector.core import build_insert_statement
 from sqlspec.adapters.mysqlconnector.driver import MysqlConnectorAsyncDriver, MysqlConnectorSyncDriver
 
 _CAPS: dict[str, Any] = {
@@ -112,12 +111,6 @@ def test_sync_load_from_arrow_overwrite_truncates_first() -> None:
     assert conn._cursor.execute_calls[0] == "TRUNCATE TABLE `orders`"
 
 
-def test_build_insert_statement_preserves_backtick_quoted_dots() -> None:
-    statement = build_insert_statement("`analytics.db`.`orders.table`", ["id"])
-
-    assert statement == "INSERT INTO `analytics.db`.`orders.table` (`id`) VALUES (%s)"
-
-
 async def test_async_load_from_arrow_local_infile_writes_tsv_and_loads() -> None:
     conn = _FakeAsyncConnection()
     driver = MysqlConnectorAsyncDriver(