sqlspec 0.24.1__py3-none-any.whl → 0.26.0__py3-none-any.whl

sqlspec/adapters/adbc/type_converter.py

@@ -0,0 +1,159 @@
+"""ADBC-specific type conversion with multi-dialect support.
+
+Provides specialized type handling for ADBC adapters, including dialect-aware
+type conversion for different database backends (PostgreSQL, SQLite, DuckDB,
+MySQL, BigQuery, Snowflake).
+"""
+
+from typing import Any
+
+from sqlspec.core.type_conversion import BaseTypeConverter
+from sqlspec.utils.serializers import to_json
+
+
+class ADBCTypeConverter(BaseTypeConverter):
+    """ADBC-specific type converter with dialect awareness.
+
+    Extends the base BaseTypeConverter with ADBC multi-backend functionality
+    including dialect-specific type handling for different database systems.
+    """
+
+    __slots__ = ("dialect",)
+
+    def __init__(self, dialect: str) -> None:
+        """Initialize with dialect-specific configuration.
+
+        Args:
+            dialect: Target database dialect (postgres, sqlite, duckdb, etc.)
+        """
+        super().__init__()
+        self.dialect = dialect.lower()
+
+    def convert_if_detected(self, value: Any) -> Any:
+        """Convert value with dialect-specific handling.
+
+        Args:
+            value: Value to potentially convert.
+
+        Returns:
+            Converted value if special type detected, original value otherwise.
+        """
+        if not isinstance(value, str):
+            return value
+
+        if not any(c in value for c in ["{", "[", "-", ":", "T"]):
+            return value
+
+        detected_type = self.detect_type(value)
+        if detected_type:
+            try:
+                if self.dialect in {"postgres", "postgresql"}:
+                    if detected_type in {"uuid", "interval"}:
+                        return self.convert_value(value, detected_type)
+
+                elif self.dialect == "duckdb":
+                    if detected_type == "uuid":
+                        return self.convert_value(value, detected_type)
+
+                elif self.dialect == "sqlite":
+                    if detected_type == "uuid":
+                        return str(value)
+
+                elif self.dialect == "bigquery":
+                    if detected_type == "uuid":
+                        return self.convert_value(value, detected_type)
+
+                elif self.dialect in {"mysql", "snowflake"} and detected_type in {"uuid", "json"}:
+                    return self.convert_value(value, detected_type)
+
+                return self.convert_value(value, detected_type)
+            except Exception:
+                return value
+
+        return value
+
+    def convert_dict(self, value: dict[str, Any]) -> Any:
+        """Convert dictionary values with dialect-specific handling.
+
+        Args:
+            value: Dictionary to convert.
+
+        Returns:
+            Converted value appropriate for the dialect.
+        """
+
+        # For dialects that cannot handle raw dicts (like ADBC PostgreSQL),
+        # convert to JSON strings
+        if self.dialect in {"postgres", "postgresql", "bigquery"}:
+            return to_json(value)
+
+        # For other dialects, pass through unchanged
+        return value
+
+    def supports_native_type(self, type_name: str) -> bool:
+        """Check if dialect supports native handling of a type.
+
+        Args:
+            type_name: Type name to check (e.g., 'uuid', 'json')
+
+        Returns:
+            True if dialect supports native handling, False otherwise.
+        """
+        native_support: dict[str, list[str]] = {
+            "postgres": ["uuid", "json", "interval", "pg_array"],
+            "postgresql": ["uuid", "json", "interval", "pg_array"],
+            "duckdb": ["uuid", "json"],
+            "bigquery": ["json"],
+            "sqlite": [],  # Limited native type support
+            "mysql": ["json"],
+            "snowflake": ["json"],
+        }
+
+        return type_name in native_support.get(self.dialect, [])
+
+    def get_dialect_specific_converter(self, value: Any, target_type: str) -> Any:
+        """Apply dialect-specific conversion logic.
+
+        Args:
+            value: Value to convert.
+            target_type: Target type for conversion.
+
+        Returns:
+            Converted value according to dialect requirements.
+        """
+        if self.dialect in {"postgres", "postgresql"}:
+            if target_type in {"uuid", "json", "interval"}:
+                return self.convert_value(value, target_type)
+
+        elif self.dialect == "duckdb":
+            if target_type in {"uuid", "json"}:
+                return self.convert_value(value, target_type)
+
+        elif self.dialect == "sqlite":
+            if target_type == "uuid":
+                return str(value)
+            if target_type == "json":
+                return self.convert_value(value, target_type)
+
+        elif self.dialect == "bigquery":
+            if target_type == "uuid":
+                return str(self.convert_value(value, target_type))
+            if target_type == "json":
+                return self.convert_value(value, target_type)
+
+        return self.convert_value(value, target_type) if hasattr(self, "convert_value") else value
+
+
+def get_adbc_type_converter(dialect: str) -> ADBCTypeConverter:
+    """Factory function to create dialect-specific ADBC type converter.
+
+    Args:
+        dialect: Database dialect name.
+
+    Returns:
+        Configured ADBCTypeConverter instance.
+    """
+    return ADBCTypeConverter(dialect)
+
+
+__all__ = ("ADBCTypeConverter", "get_adbc_type_converter")

sqlspec/adapters/aiosqlite/config.py

@@ -62,6 +62,7 @@ class AiosqliteConfig(AsyncDatabaseConfig["AiosqliteConnection", AiosqliteConnec
         migration_config: "Optional[dict[str, Any]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         driver_features: "Optional[dict[str, Any]]" = None,
+        bind_key: "Optional[str]" = None,
     ) -> None:
         """Initialize AioSQLite configuration.
 
@@ -71,6 +72,7 @@ class AiosqliteConfig(AsyncDatabaseConfig["AiosqliteConnection", AiosqliteConnec
             migration_config: Optional migration configuration.
             statement_config: Optional statement configuration.
             driver_features: Optional driver feature configuration.
+            bind_key: Optional unique identifier for this configuration.
         """
         config_dict = dict(pool_config) if pool_config else {}
 
@@ -84,6 +86,7 @@ class AiosqliteConfig(AsyncDatabaseConfig["AiosqliteConnection", AiosqliteConnec
             migration_config=migration_config,
             statement_config=statement_config or aiosqlite_statement_config,
             driver_features=driver_features or {},
+            bind_key=bind_key,
         )
 
     def _get_pool_config_dict(self) -> "dict[str, Any]":

sqlspec/adapters/aiosqlite/data_dictionary.py

@@ -0,0 +1,117 @@
+"""SQLite-specific data dictionary for metadata queries via aiosqlite."""
+
+import re
+from typing import TYPE_CHECKING, Callable, Optional, cast
+
+from sqlspec.driver import AsyncDataDictionaryBase, AsyncDriverAdapterBase, VersionInfo
+from sqlspec.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    from sqlspec.adapters.aiosqlite.driver import AiosqliteDriver
+
+logger = get_logger("adapters.aiosqlite.data_dictionary")
+
+# Compiled regex patterns
+SQLITE_VERSION_PATTERN = re.compile(r"(\d+)\.(\d+)\.(\d+)")
+
+__all__ = ("AiosqliteAsyncDataDictionary",)
+
+
+class AiosqliteAsyncDataDictionary(AsyncDataDictionaryBase):
+    """SQLite-specific async data dictionary via aiosqlite."""
+
+    async def get_version(self, driver: AsyncDriverAdapterBase) -> "Optional[VersionInfo]":
+        """Get SQLite database version information.
+
+        Args:
+            driver: Async database driver instance
+
+        Returns:
+            SQLite version information or None if detection fails
+        """
+        version_str = await cast("AiosqliteDriver", driver).select_value("SELECT sqlite_version()")
+        if not version_str:
+            logger.warning("No SQLite version information found")
+            return None
+
+        # Parse version like "3.45.0"
+        version_match = SQLITE_VERSION_PATTERN.match(str(version_str))
+        if not version_match:
+            logger.warning("Could not parse SQLite version: %s", version_str)
+            return None
+
+        major, minor, patch = map(int, version_match.groups())
+        version_info = VersionInfo(major, minor, patch)
+        logger.debug("Detected SQLite version: %s", version_info)
+        return version_info
+
+    async def get_feature_flag(self, driver: AsyncDriverAdapterBase, feature: str) -> bool:
+        """Check if SQLite database supports a specific feature.
+
+        Args:
+            driver: AIOSQLite driver instance
+            feature: Feature name to check
+
+        Returns:
+            True if feature is supported, False otherwise
+        """
+        version_info = await self.get_version(driver)
+        if not version_info:
+            return False
+
+        feature_checks: dict[str, Callable[..., bool]] = {
+            "supports_json": lambda v: v >= VersionInfo(3, 38, 0),
+            "supports_returning": lambda v: v >= VersionInfo(3, 35, 0),
+            "supports_upsert": lambda v: v >= VersionInfo(3, 24, 0),
+            "supports_window_functions": lambda v: v >= VersionInfo(3, 25, 0),
+            "supports_cte": lambda v: v >= VersionInfo(3, 8, 3),
+            "supports_transactions": lambda _: True,
+            "supports_prepared_statements": lambda _: True,
+            "supports_schemas": lambda _: False,  # SQLite has ATTACH but not schemas
+            "supports_arrays": lambda _: False,
+            "supports_uuid": lambda _: False,
+        }
+
+        if feature in feature_checks:
+            return bool(feature_checks[feature](version_info))
+
+        return False
+
+    async def get_optimal_type(self, driver: AsyncDriverAdapterBase, type_category: str) -> str:
+        """Get optimal SQLite type for a category.
+
+        Args:
+            driver: AIOSQLite driver instance
+            type_category: Type category
+
+        Returns:
+            SQLite-specific type name
+        """
+        version_info = await self.get_version(driver)
+
+        if type_category == "json":
+            if version_info and version_info >= VersionInfo(3, 38, 0):
+                return "JSON"
+            return "TEXT"
+
+        type_map = {"uuid": "TEXT", "boolean": "INTEGER", "timestamp": "TIMESTAMP", "text": "TEXT", "blob": "BLOB"}
+        return type_map.get(type_category, "TEXT")
+
+    def list_available_features(self) -> "list[str]":
+        """List available SQLite feature flags.
+
+        Returns:
+            List of supported feature names
+        """
+        return [
+            "supports_json",
+            "supports_returning",
+            "supports_upsert",
+            "supports_window_functions",
+            "supports_cte",
+            "supports_transactions",
+            "supports_prepared_statements",
+            "supports_schemas",
+            "supports_arrays",
+            "supports_uuid",
+        ]

sqlspec/adapters/aiosqlite/driver.py

@@ -22,6 +22,7 @@ if TYPE_CHECKING:
     from sqlspec.core.result import SQLResult
     from sqlspec.core.statement import SQL
     from sqlspec.driver import ExecutionResult
+    from sqlspec.driver._async import AsyncDataDictionaryBase
 
 __all__ = ("AiosqliteCursor", "AiosqliteDriver", "AiosqliteExceptionHandler", "aiosqlite_statement_config")
 
@@ -66,8 +67,7 @@ class AiosqliteCursor:
         self.cursor = await self.connection.cursor()
         return self.cursor
 
-    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        _ = (exc_type, exc_val, exc_tb)
+    async def __aexit__(self, *_: Any) -> None:
         if self.cursor is not None:
             with contextlib.suppress(Exception):
                 await self.cursor.close()
@@ -120,7 +120,7 @@ class AiosqliteExceptionHandler:
 class AiosqliteDriver(AsyncDriverAdapterBase):
     """AIOSQLite driver for async SQLite database operations."""
 
-    __slots__ = ()
+    __slots__ = ("_data_dictionary",)
     dialect = "sqlite"
 
     def __init__(
@@ -134,6 +134,7 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
             statement_config = aiosqlite_statement_config.replace(enable_caching=cache_config.compiled_cache_enabled)
 
         super().__init__(connection=connection, statement_config=statement_config, driver_features=driver_features)
+        self._data_dictionary: Optional[AsyncDataDictionaryBase] = None
 
     def with_cursor(self, connection: "AiosqliteConnection") -> "AiosqliteCursor":
         """Create async context manager for AIOSQLite cursor."""
@@ -241,3 +242,16 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
         except aiosqlite.Error as e:
             msg = f"Failed to commit transaction: {e}"
             raise SQLSpecError(msg) from e
+
+    @property
+    def data_dictionary(self) -> "AsyncDataDictionaryBase":
+        """Get the data dictionary for this driver.
+
+        Returns:
+            Data dictionary instance for metadata queries
+        """
+        if self._data_dictionary is None:
+            from sqlspec.adapters.aiosqlite.data_dictionary import AiosqliteAsyncDataDictionary
+
+            self._data_dictionary = AiosqliteAsyncDataDictionary()
+        return self._data_dictionary

sqlspec/adapters/asyncmy/_types.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from asyncmy import Connection
+from asyncmy import Connection  # pyright: ignore
 
 if TYPE_CHECKING:
     from typing_extensions import TypeAlias

sqlspec/adapters/asyncmy/config.py

@@ -6,8 +6,8 @@ from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypedDict, Union
 
 import asyncmy
-from asyncmy.cursors import Cursor, DictCursor
-from asyncmy.pool import Pool as AsyncmyPool
+from asyncmy.cursors import Cursor, DictCursor  # pyright: ignore
+from asyncmy.pool import Pool as AsyncmyPool  # pyright: ignore
 from typing_extensions import NotRequired
 
 from sqlspec.adapters.asyncmy._types import AsyncmyConnection
@@ -15,8 +15,8 @@ from sqlspec.adapters.asyncmy.driver import AsyncmyCursor, AsyncmyDriver, asyncm
 from sqlspec.config import AsyncDatabaseConfig
 
 if TYPE_CHECKING:
-    from asyncmy.cursors import Cursor, DictCursor
-    from asyncmy.pool import Pool
+    from asyncmy.cursors import Cursor, DictCursor  # pyright: ignore
+    from asyncmy.pool import Pool  # pyright: ignore
 
     from sqlspec.core.statement import StatementConfig
 
@@ -57,7 +57,7 @@ class AsyncmyPoolParams(AsyncmyConnectionParams, total=False):
     pool_recycle: NotRequired[int]
 
 
-class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver]):  # pyright: ignore
+class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "AsyncmyPool", AsyncmyDriver]):  # pyright: ignore
     """Configuration for Asyncmy database connections."""
 
     driver_type: ClassVar[type[AsyncmyDriver]] = AsyncmyDriver
@@ -67,10 +67,11 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
         self,
         *,
         pool_config: "Optional[Union[AsyncmyPoolParams, dict[str, Any]]]" = None,
-        pool_instance: "Optional[Pool]" = None,
+        pool_instance: "Optional[AsyncmyPool]" = None,
         migration_config: Optional[dict[str, Any]] = None,
         statement_config: "Optional[StatementConfig]" = None,
         driver_features: "Optional[dict[str, Any]]" = None,
+        bind_key: "Optional[str]" = None,
     ) -> None:
         """Initialize Asyncmy configuration.
 
@@ -80,6 +81,7 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
             migration_config: Migration configuration
             statement_config: Statement configuration override
             driver_features: Driver feature configuration
+            bind_key: Optional unique identifier for this configuration
         """
         processed_pool_config: dict[str, Any] = dict(pool_config) if pool_config else {}
         if "extra" in processed_pool_config:
@@ -100,11 +102,12 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
             migration_config=migration_config,
             statement_config=statement_config,
             driver_features=driver_features or {},
+            bind_key=bind_key,
         )
 
-    async def _create_pool(self) -> "Pool":  # pyright: ignore
+    async def _create_pool(self) -> "AsyncmyPool":  # pyright: ignore
         """Create the actual async connection pool."""
-        return await asyncmy.create_pool(**dict(self.pool_config))
+        return await asyncmy.create_pool(**dict(self.pool_config))  # pyright: ignore
 
     async def _close_pool(self) -> None:
         """Close the actual async connection pool."""

sqlspec/adapters/asyncmy/data_dictionary.py

@@ -0,0 +1,122 @@
+"""MySQL-specific data dictionary for metadata queries via asyncmy."""
+
+import re
+from typing import TYPE_CHECKING, Callable, Optional, cast
+
+from sqlspec.driver import AsyncDataDictionaryBase, AsyncDriverAdapterBase, VersionInfo
+from sqlspec.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    from sqlspec.adapters.asyncmy.driver import AsyncmyDriver
+
+logger = get_logger("adapters.asyncmy.data_dictionary")
+
+# Compiled regex patterns
+VERSION_PATTERN = re.compile(r"(\d+)\.(\d+)\.(\d+)")
+
+__all__ = ("MySQLAsyncDataDictionary",)
+
+
+class MySQLAsyncDataDictionary(AsyncDataDictionaryBase):
+    """MySQL-specific async data dictionary."""
+
+    async def get_version(self, driver: AsyncDriverAdapterBase) -> "Optional[VersionInfo]":
+        """Get MySQL database version information.
+
+        Args:
+            driver: Async database driver instance
+
+        Returns:
+            MySQL version information or None if detection fails
+        """
+        result = await cast("AsyncmyDriver", driver).select_value_or_none("SELECT VERSION() as version")
+        if not result:
+            logger.warning("No MySQL version information found")
+
+        # Parse version like "8.0.33-0ubuntu0.22.04.2" or "5.7.42-log"
+        version_match = VERSION_PATTERN.search(str(result))
+        if not version_match:
+            logger.warning("Could not parse MySQL version: %s", result)
+            return None
+
+        major, minor, patch = map(int, version_match.groups())
+        version_info = VersionInfo(major, minor, patch)
+        logger.debug("Detected MySQL version: %s", version_info)
+        return version_info
+
+    async def get_feature_flag(self, driver: AsyncDriverAdapterBase, feature: str) -> bool:
+        """Check if MySQL database supports a specific feature.
+
+        Args:
+            driver: MySQL async driver instance
+            feature: Feature name to check
+
+        Returns:
+            True if feature is supported, False otherwise
+        """
+        version_info = await self.get_version(driver)
+        if not version_info:
+            return False
+
+        feature_checks: dict[str, Callable[..., bool]] = {
+            "supports_json": lambda v: v >= VersionInfo(5, 7, 8),
+            "supports_cte": lambda v: v >= VersionInfo(8, 0, 1),
+            "supports_window_functions": lambda v: v >= VersionInfo(8, 0, 2),
+            "supports_returning": lambda _: False,  # MySQL doesn't have RETURNING
+            "supports_upsert": lambda _: True,  # ON DUPLICATE KEY UPDATE available
+            "supports_transactions": lambda _: True,
+            "supports_prepared_statements": lambda _: True,
+            "supports_schemas": lambda _: True,  # MySQL calls them databases
+            "supports_arrays": lambda _: False,  # No array types
+            "supports_uuid": lambda _: False,  # No native UUID, use VARCHAR(36)
+        }
+
+        if feature in feature_checks:
+            return bool(feature_checks[feature](version_info))
+
+        return False
+
+    async def get_optimal_type(self, driver: AsyncDriverAdapterBase, type_category: str) -> str:
+        """Get optimal MySQL type for a category.
+
+        Args:
+            driver: MySQL async driver instance
+            type_category: Type category
+
+        Returns:
+            MySQL-specific type name
+        """
+        version_info = await self.get_version(driver)
+
+        if type_category == "json":
+            if version_info and version_info >= VersionInfo(5, 7, 8):
+                return "JSON"
+            return "TEXT"
+
+        type_map = {
+            "uuid": "VARCHAR(36)",
+            "boolean": "TINYINT(1)",
+            "timestamp": "TIMESTAMP",
+            "text": "TEXT",
+            "blob": "BLOB",
+        }
+        return type_map.get(type_category, "VARCHAR(255)")
+
+    def list_available_features(self) -> "list[str]":
+        """List available MySQL feature flags.
+
+        Returns:
+            List of supported feature names
+        """
+        return [
+            "supports_json",
+            "supports_cte",
+            "supports_window_functions",
+            "supports_returning",
+            "supports_upsert",
+            "supports_transactions",
+            "supports_prepared_statements",
+            "supports_schemas",
+            "supports_arrays",
+            "supports_uuid",
+        ]

sqlspec/adapters/asyncmy/driver.py

@@ -8,8 +8,8 @@ import logging
 from typing import TYPE_CHECKING, Any, Optional, Union
 
 import asyncmy
-import asyncmy.errors
-from asyncmy.cursors import Cursor, DictCursor
+import asyncmy.errors  # pyright: ignore
+from asyncmy.cursors import Cursor, DictCursor  # pyright: ignore
 
 from sqlspec.core.cache import get_cache_config
 from sqlspec.core.parameters import ParameterStyle, ParameterStyleConfig
@@ -25,6 +25,7 @@ if TYPE_CHECKING:
     from sqlspec.core.result import SQLResult
     from sqlspec.core.statement import SQL
     from sqlspec.driver import ExecutionResult
+    from sqlspec.driver._async import AsyncDataDictionaryBase
 
 logger = logging.getLogger(__name__)
 
@@ -66,8 +67,7 @@ class AsyncmyCursor:
         self.cursor = self.connection.cursor()
         return self.cursor
 
-    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        _ = (exc_type, exc_val, exc_tb)
+    async def __aexit__(self, *_: Any) -> None:
         if self.cursor is not None:
             await self.cursor.close()
 
@@ -84,9 +84,9 @@ class AsyncmyExceptionHandler:
     async def __aenter__(self) -> None:
         return None
 
-    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> "Optional[bool]":
         if exc_type is None:
-            return
+            return None
 
         if issubclass(exc_type, asyncmy.errors.IntegrityError):
             e = exc_val
@@ -102,6 +102,15 @@ class AsyncmyExceptionHandler:
             raise SQLSpecError(msg) from e
         if issubclass(exc_type, asyncmy.errors.OperationalError):
             e = exc_val
+            # Handle specific MySQL errors that are expected in migrations
+            if hasattr(e, "args") and len(e.args) >= 1 and isinstance(e.args[0], int):
+                error_code = e.args[0]
+                # Error 1061: Duplicate key name (index already exists)
+                # Error 1091: Can't DROP index that doesn't exist
+                if error_code in {1061, 1091}:
+                    # These are acceptable during migrations - log and continue
+                    logger.warning("AsyncMy MySQL expected migration error (ignoring): %s", e)
+                    return True  # Suppress the exception by returning True
             msg = f"AsyncMy MySQL operational error: {e}"
             raise SQLSpecError(msg) from e
         if issubclass(exc_type, asyncmy.errors.DatabaseError):
@@ -120,6 +129,7 @@ class AsyncmyExceptionHandler:
                 raise SQLParsingError(msg) from e
             msg = f"Unexpected async database operation error: {e}"
             raise SQLSpecError(msg) from e
+        return None
 
 
 class AsyncmyDriver(AsyncDriverAdapterBase):
@@ -130,7 +140,7 @@ class AsyncmyDriver(AsyncDriverAdapterBase):
     and transaction management.
     """
 
-    __slots__ = ()
+    __slots__ = ("_data_dictionary",)
     dialect = "mysql"
 
     def __init__(
@@ -149,6 +159,7 @@ class AsyncmyDriver(AsyncDriverAdapterBase):
             )
 
         super().__init__(connection=connection, statement_config=statement_config, driver_features=driver_features)
+        self._data_dictionary: Optional[AsyncDataDictionaryBase] = None
 
     def with_cursor(self, connection: "AsyncmyConnection") -> "AsyncmyCursor":
         """Create cursor context manager for the connection.
@@ -308,3 +319,16 @@ class AsyncmyDriver(AsyncDriverAdapterBase):
         except asyncmy.errors.MySQLError as e:
             msg = f"Failed to commit MySQL transaction: {e}"
             raise SQLSpecError(msg) from e
+
+    @property
+    def data_dictionary(self) -> "AsyncDataDictionaryBase":
+        """Get the data dictionary for this driver.
+
+        Returns:
+            Data dictionary instance for metadata queries
+        """
+        if self._data_dictionary is None:
+            from sqlspec.adapters.asyncmy.data_dictionary import MySQLAsyncDataDictionary
+
+            self._data_dictionary = MySQLAsyncDataDictionary()
+        return self._data_dictionary

sqlspec/adapters/asyncpg/config.py

@@ -84,6 +84,7 @@ class AsyncpgConfig(AsyncDatabaseConfig[AsyncpgConnection, "Pool[Record]", Async
         migration_config: "Optional[dict[str, Any]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         driver_features: "Optional[Union[AsyncpgDriverFeatures, dict[str, Any]]]" = None,
+        bind_key: "Optional[str]" = None,
     ) -> None:
         """Initialize AsyncPG configuration.
 
@@ -93,6 +94,7 @@ class AsyncpgConfig(AsyncDatabaseConfig[AsyncpgConnection, "Pool[Record]", Async
             migration_config: Migration configuration
             statement_config: Statement configuration override
             driver_features: Driver features configuration (TypedDict or dict)
+            bind_key: Optional unique identifier for this configuration
         """
         features_dict: dict[str, Any] = dict(driver_features) if driver_features else {}
 
@@ -106,6 +108,7 @@ class AsyncpgConfig(AsyncDatabaseConfig[AsyncpgConnection, "Pool[Record]", Async
             migration_config=migration_config,
             statement_config=statement_config or asyncpg_statement_config,
             driver_features=features_dict,
+            bind_key=bind_key,
         )
 
     def _get_pool_config_dict(self) -> "dict[str, Any]":