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

sqlspec/config.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Generic, Optional, TypeVar, Union
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Generic, Optional, TypeVar, Union, cast
 
 from typing_extensions import NotRequired, TypedDict
 
@@ -11,11 +12,10 @@ from sqlspec.utils.logging import get_logger
 if TYPE_CHECKING:
     from collections.abc import Awaitable
     from contextlib import AbstractAsyncContextManager, AbstractContextManager
-    from pathlib import Path
 
     from sqlspec.driver import AsyncDriverAdapterBase, SyncDriverAdapterBase
     from sqlspec.loader import SQLFileLoader
-    from sqlspec.migrations.commands import MigrationCommands
+    from sqlspec.migrations.commands import AsyncMigrationCommands, SyncMigrationCommands
 
 
 __all__ = (
@@ -89,6 +89,7 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
     __slots__ = (
         "_migration_commands",
         "_migration_loader",
+        "bind_key",
         "driver_features",
         "migration_config",
         "pool_instance",
@@ -96,7 +97,7 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
     )
 
     _migration_loader: "SQLFileLoader"
-    _migration_commands: "MigrationCommands"
+    _migration_commands: "Union[SyncMigrationCommands, AsyncMigrationCommands]"
     driver_type: "ClassVar[type[Any]]"
     connection_type: "ClassVar[type[Any]]"
     is_async: "ClassVar[bool]" = False
@@ -105,6 +106,7 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
     supports_native_arrow_export: "ClassVar[bool]" = False
     supports_native_parquet_import: "ClassVar[bool]" = False
     supports_native_parquet_export: "ClassVar[bool]" = False
+    bind_key: "Optional[str]"
     statement_config: "StatementConfig"
     pool_instance: "Optional[PoolT]"
     migration_config: "Union[dict[str, Any], MigrationConfig]"
@@ -176,10 +178,10 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
         at runtime when needed.
         """
         from sqlspec.loader import SQLFileLoader
-        from sqlspec.migrations.commands import MigrationCommands
+        from sqlspec.migrations.commands import create_migration_commands
 
         self._migration_loader = SQLFileLoader()
-        self._migration_commands = MigrationCommands(self)  # type: ignore[arg-type]
+        self._migration_commands = create_migration_commands(self)  # type: ignore[arg-type]
 
     def _ensure_migration_loader(self) -> "SQLFileLoader":
         """Get the migration SQL loader and auto-load files if needed.
@@ -200,7 +202,7 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
 
         return self._migration_loader
 
-    def _ensure_migration_commands(self) -> "MigrationCommands":
+    def _ensure_migration_commands(self) -> "Union[SyncMigrationCommands, AsyncMigrationCommands]":
         """Get the migration commands instance.
 
         Returns:
@@ -225,7 +227,6 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
         Args:
             *paths: One or more file paths or directory paths to load migration SQL files from.
         """
-        from pathlib import Path
 
         loader = self._ensure_migration_loader()
         for path in paths:
@@ -236,7 +237,7 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
             else:
                 logger.warning("Migration path does not exist: %s", path_obj)
 
-    def get_migration_commands(self) -> "MigrationCommands":
+    def get_migration_commands(self) -> "Union[SyncMigrationCommands, AsyncMigrationCommands]":
         """Get migration commands for this configuration.
 
         Returns:
@@ -244,25 +245,27 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
         """
         return self._ensure_migration_commands()
 
-    def migrate_up(self, revision: str = "head") -> None:
+    async def migrate_up(self, revision: str = "head") -> None:
         """Apply migrations up to the specified revision.
 
         Args:
             revision: Target revision or "head" for latest. Defaults to "head".
         """
         commands = self._ensure_migration_commands()
-        commands.upgrade(revision)
 
-    def migrate_down(self, revision: str = "-1") -> None:
+        await cast("AsyncMigrationCommands", commands).upgrade(revision)
+
+    async def migrate_down(self, revision: str = "-1") -> None:
         """Apply migrations down to the specified revision.
 
         Args:
             revision: Target revision, "-1" for one step back, or "base" for all migrations. Defaults to "-1".
         """
         commands = self._ensure_migration_commands()
-        commands.downgrade(revision)
 
-    def get_current_migration(self, verbose: bool = False) -> "Optional[str]":
+        await cast("AsyncMigrationCommands", commands).downgrade(revision)
+
+    async def get_current_migration(self, verbose: bool = False) -> "Optional[str]":
         """Get the current migration version.
 
         Args:
@@ -272,9 +275,10 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
             Current migration version or None if no migrations applied.
         """
         commands = self._ensure_migration_commands()
-        return commands.current(verbose=verbose)
 
-    def create_migration(self, message: str, file_type: str = "sql") -> None:
+        return await cast("AsyncMigrationCommands", commands).current(verbose=verbose)
+
+    async def create_migration(self, message: str, file_type: str = "sql") -> None:
         """Create a new migration file.
 
         Args:
@@ -282,9 +286,10 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
             file_type: Type of migration file to create ('sql' or 'py'). Defaults to 'sql'.
         """
         commands = self._ensure_migration_commands()
-        commands.revision(message, file_type)
 
-    def init_migrations(self, directory: "Optional[str]" = None, package: bool = True) -> None:
+        await cast("AsyncMigrationCommands", commands).revision(message, file_type)
+
+    async def init_migrations(self, directory: "Optional[str]" = None, package: bool = True) -> None:
         """Initialize migration directory structure.
 
         Args:
@@ -297,7 +302,8 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
 
         commands = self._ensure_migration_commands()
         assert directory is not None
-        commands.init(directory, package)
+
+        await cast("AsyncMigrationCommands", commands).init(directory, package)
 
 
 class NoPoolSyncConfig(DatabaseConfigProtocol[ConnectionT, None, DriverT]):
@@ -315,7 +321,9 @@ class NoPoolSyncConfig(DatabaseConfigProtocol[ConnectionT, None, DriverT]):
         migration_config: "Optional[Union[dict[str, Any], MigrationConfig]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         driver_features: "Optional[dict[str, Any]]" = None,
+        bind_key: "Optional[str]" = None,
     ) -> None:
+        self.bind_key = bind_key
         self.pool_instance = None
         self.connection_config = connection_config or {}
         self.migration_config: Union[dict[str, Any], MigrationConfig] = migration_config or {}
@@ -369,7 +377,9 @@ class NoPoolAsyncConfig(DatabaseConfigProtocol[ConnectionT, None, DriverT]):
         migration_config: "Optional[Union[dict[str, Any], MigrationConfig]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         driver_features: "Optional[dict[str, Any]]" = None,
+        bind_key: "Optional[str]" = None,
     ) -> None:
+        self.bind_key = bind_key
         self.pool_instance = None
         self.connection_config = connection_config or {}
         self.migration_config: Union[dict[str, Any], MigrationConfig] = migration_config or {}
@@ -424,7 +434,9 @@ class SyncDatabaseConfig(DatabaseConfigProtocol[ConnectionT, PoolT, DriverT]):
         migration_config: "Optional[Union[dict[str, Any], MigrationConfig]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         driver_features: "Optional[dict[str, Any]]" = None,
+        bind_key: "Optional[str]" = None,
     ) -> None:
+        self.bind_key = bind_key
         self.pool_instance = pool_instance
         self.pool_config = pool_config or {}
         self.migration_config: Union[dict[str, Any], MigrationConfig] = migration_config or {}
@@ -501,7 +513,9 @@ class AsyncDatabaseConfig(DatabaseConfigProtocol[ConnectionT, PoolT, DriverT]):
         migration_config: "Optional[Union[dict[str, Any], MigrationConfig]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         driver_features: "Optional[dict[str, Any]]" = None,
+        bind_key: "Optional[str]" = None,
     ) -> None:
+        self.bind_key = bind_key
         self.pool_instance = pool_instance
         self.pool_config = pool_config or {}
         self.migration_config: Union[dict[str, Any], MigrationConfig] = migration_config or {}

sqlspec/core/cache.py

@@ -14,7 +14,7 @@ Components:
 import threading
 import time
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Final, Optional
+from typing import TYPE_CHECKING, Any, Final, Optional, Union
 
 from mypy_extensions import mypyc_attr
 from typing_extensions import TypeVar
@@ -558,7 +558,7 @@ class CachedStatement:
     """
 
     compiled_sql: str
-    parameters: Optional[tuple[Any, ...]]  # None allowed for static script compilation
+    parameters: Optional[Union[tuple[Any, ...], dict[str, Any]]]  # None allowed for static script compilation
     expression: Optional["exp.Expression"]
 
     def get_parameters_view(self) -> "ParametersView":

sqlspec/core/compiler.py

@@ -72,6 +72,7 @@ class CompiledSQL:
         "execution_parameters",
         "expression",
         "operation_type",
+        "parameter_casts",
         "parameter_style",
         "supports_many",
     )
@@ -86,6 +87,7 @@ class CompiledSQL:
         expression: Optional["exp.Expression"] = None,
         parameter_style: Optional[str] = None,
         supports_many: bool = False,
+        parameter_casts: Optional["dict[int, str]"] = None,
     ) -> None:
         """Initialize compiled result.
 
@@ -96,6 +98,7 @@ class CompiledSQL:
             expression: SQLGlot AST expression
             parameter_style: Parameter style used in compilation
             supports_many: Whether this supports execute_many operations
+            parameter_casts: Mapping of parameter positions to cast types
         """
         self.compiled_sql = compiled_sql
         self.execution_parameters = execution_parameters
@@ -103,6 +106,7 @@ class CompiledSQL:
         self.expression = expression
         self.parameter_style = parameter_style
         self.supports_many = supports_many
+        self.parameter_casts = parameter_casts or {}
         self._hash: Optional[int] = None
 
     def __hash__(self) -> int:
@@ -224,11 +228,13 @@ class SQLProcessor:
             ast_was_transformed = False
             expression = None
             operation_type: OperationType = "EXECUTE"
+            parameter_casts: dict[int, str] = {}
 
             if self._config.enable_parsing:
                 try:
                     expression = sqlglot.parse_one(sqlglot_sql, dialect=dialect_str)
                     operation_type = self._detect_operation_type(expression)
+                    parameter_casts = self._detect_parameter_casts(expression)
 
                     ast_transformer = self._config.parameter_config.ast_transformer
                     if ast_transformer:
@@ -238,6 +244,7 @@ class SQLProcessor:
                 except ParseError:
                     expression = None
                     operation_type = "EXECUTE"
+                    parameter_casts = {}
 
             if self._config.parameter_config.needs_static_script_compilation and processed_params is None:
                 final_sql, final_params = processed_sql, processed_params
@@ -264,6 +271,7 @@ class SQLProcessor:
                 expression=expression,
                 parameter_style=self._config.parameter_config.default_parameter_style.value,
                 supports_many=isinstance(final_params, list) and len(final_params) > 0,
+                parameter_casts=parameter_casts,
             )
 
         except SQLSpecError:
@@ -271,7 +279,9 @@ class SQLProcessor:
             raise
         except Exception as e:
             logger.warning("Compilation failed, using fallback: %s", e)
-            return CompiledSQL(compiled_sql=sql, execution_parameters=parameters, operation_type="UNKNOWN")
+            return CompiledSQL(
+                compiled_sql=sql, execution_parameters=parameters, operation_type="UNKNOWN", parameter_casts={}
+            )
 
     def _make_cache_key(self, sql: str, parameters: Any, is_many: bool = False) -> str:
         """Generate cache key.
@@ -326,6 +336,51 @@ class SQLProcessor:
 
         return "UNKNOWN"
 
+    def _detect_parameter_casts(self, expression: Optional["exp.Expression"]) -> "dict[int, str]":
+        """Detect explicit type casts on parameters in the AST.
+
+        Args:
+            expression: SQLGlot AST expression to analyze
+
+        Returns:
+            Dict mapping parameter positions (1-based) to cast type names
+        """
+        if not expression:
+            return {}
+
+        cast_positions = {}
+
+        # Walk all nodes in order to track parameter positions
+        for node in expression.walk():
+            # Check for cast nodes with parameter children
+            if isinstance(node, exp.Cast):
+                cast_target = node.this
+                position = None
+
+                if isinstance(cast_target, exp.Parameter):
+                    # Handle $1, $2 style parameters
+                    param_value = cast_target.this
+                    if isinstance(param_value, exp.Literal):
+                        position = int(param_value.this)
+                elif isinstance(cast_target, exp.Placeholder):
+                    # For ? style, we need to count position (will implement if needed)
+                    pass
+                elif isinstance(cast_target, exp.Column):
+                    # Handle cases where $1 gets parsed as a column
+                    column_name = str(cast_target.this) if cast_target.this else str(cast_target)
+                    if column_name.startswith("$") and column_name[1:].isdigit():
+                        position = int(column_name[1:])
+
+                if position is not None:
+                    # Extract cast type
+                    if isinstance(node.to, exp.DataType):
+                        cast_type = node.to.this.value if hasattr(node.to.this, "value") else str(node.to.this)
+                    else:
+                        cast_type = str(node.to)
+                    cast_positions[position] = cast_type.upper()
+
+        return cast_positions
+
     def _apply_final_transformations(
         self, expression: "Optional[exp.Expression]", sql: str, parameters: Any, dialect_str: "Optional[str]"
     ) -> "tuple[str, Any]":

sqlspec/core/parameters.py

@@ -619,7 +619,9 @@ class ParameterConverter:
 
         return converted_sql
 
-    def _convert_sequence_to_dict(self, parameters: Sequence, param_info: "list[ParameterInfo]") -> "dict[str, Any]":
+    def _convert_sequence_to_dict(
+        self, parameters: "Sequence[Any]", param_info: "list[ParameterInfo]"
+    ) -> "dict[str, Any]":
         """Convert sequence parameters to dictionary for named styles.
 
         Args:
@@ -637,7 +639,7 @@ class ParameterConverter:
         return param_dict
 
     def _extract_param_value_mixed_styles(
-        self, param: ParameterInfo, parameters: Mapping, param_keys: "list[str]"
+        self, param: ParameterInfo, parameters: "Mapping[str, Any]", param_keys: "list[str]"
     ) -> "tuple[Any, bool]":
         """Extract parameter value for mixed style parameters.
 
@@ -670,7 +672,9 @@ class ParameterConverter:
 
         return None, False
 
-    def _extract_param_value_single_style(self, param: ParameterInfo, parameters: Mapping) -> "tuple[Any, bool]":
+    def _extract_param_value_single_style(
+        self, param: ParameterInfo, parameters: "Mapping[str, Any]"
+    ) -> "tuple[Any, bool]":
         """Extract parameter value for single style parameters.
 
         Args:

sqlspec/core/statement.py

@@ -59,6 +59,7 @@ PROCESSED_STATE_SLOTS: Final = (
     "execution_parameters",
     "parsed_expression",
     "operation_type",
+    "parameter_casts",
     "validation_errors",
     "is_many",
 )
@@ -81,6 +82,7 @@ class ProcessedState:
         execution_parameters: Any,
         parsed_expression: "Optional[exp.Expression]" = None,
         operation_type: "OperationType" = "UNKNOWN",
+        parameter_casts: "Optional[dict[int, str]]" = None,
         validation_errors: "Optional[list[str]]" = None,
         is_many: bool = False,
     ) -> None:
@@ -88,6 +90,7 @@ class ProcessedState:
         self.execution_parameters = execution_parameters
         self.parsed_expression = parsed_expression
         self.operation_type = operation_type
+        self.parameter_casts = parameter_casts or {}
         self.validation_errors = validation_errors or []
         self.is_many = is_many
 
@@ -447,6 +450,7 @@ class SQL:
                     execution_parameters=compiled_result.execution_parameters,
                     parsed_expression=compiled_result.expression,
                     operation_type=compiled_result.operation_type,
+                    parameter_casts=compiled_result.parameter_casts,
                     validation_errors=[],
                     is_many=self._is_many,
                 )
@@ -458,6 +462,7 @@ class SQL:
                     compiled_sql=self._raw_sql,
                     execution_parameters=self._named_parameters or self._positional_parameters,
                     operation_type="UNKNOWN",
+                    parameter_casts={},
                     is_many=self._is_many,
                 )
 

sqlspec/core/type_conversion.py

@@ -0,0 +1,234 @@
+"""Centralized type conversion and detection for SQLSpec.
+
+Provides unified type detection and conversion utilities for all database
+adapters, with MyPyC-compatible optimizations.
+"""
+
+import re
+from datetime import date, datetime, time, timezone
+from decimal import Decimal
+from typing import Any, Callable, Final, Optional
+from uuid import UUID
+
+from sqlspec._serialization import decode_json
+
+# MyPyC-compatible pre-compiled patterns
+SPECIAL_TYPE_REGEX: Final[re.Pattern[str]] = re.compile(
+    r"^(?:"
+    r"(?P<uuid>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})|"
+    r"(?P<iso_datetime>\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)|"
+    r"(?P<iso_date>\d{4}-\d{2}-\d{2})|"
+    r"(?P<iso_time>\d{2}:\d{2}:\d{2}(?:\.\d+)?)|"
+    r"(?P<json>[\[{].*[\]}])|"
+    r"(?P<ipv4>(?:\d{1,3}\.){3}\d{1,3})|"
+    r"(?P<ipv6>(?:[0-9a-f]{1,4}:){7}[0-9a-f]{1,4})|"
+    r"(?P<mac>(?:[0-9a-f]{2}:){5}[0-9a-f]{2})"
+    r")$",
+    re.IGNORECASE | re.DOTALL,
+)
+
+
+class BaseTypeConverter:
+    """Universal type detection and conversion for all adapters.
+
+    Provides centralized type detection and conversion functionality
+    that can be used across all database adapters to ensure consistent
+    behavior. Users can extend this class for custom type conversion needs.
+    """
+
+    __slots__ = ()
+
+    def detect_type(self, value: str) -> Optional[str]:
+        """Detect special types from string values.
+
+        Args:
+            value: String value to analyze.
+
+        Returns:
+            Type name if detected, None otherwise.
+        """
+        if not isinstance(value, str):  # pyright: ignore
+            return None
+        if not value:
+            return None
+
+        match = SPECIAL_TYPE_REGEX.match(value)
+        if not match:
+            return None
+
+        return next((k for k, v in match.groupdict().items() if v), None)
+
+    def convert_value(self, value: str, detected_type: str) -> Any:
+        """Convert string value to appropriate Python type.
+
+        Args:
+            value: String value to convert.
+            detected_type: Detected type name.
+
+        Returns:
+            Converted value in appropriate Python type.
+        """
+        converter = _TYPE_CONVERTERS.get(detected_type)
+        if converter:
+            return converter(value)
+        return value
+
+    def convert_if_detected(self, value: Any) -> Any:
+        """Convert value only if special type detected, else return original.
+
+        This method provides performance optimization by avoiding expensive
+        regex operations on plain strings that don't contain special characters.
+
+        Args:
+            value: Value to potentially convert.
+
+        Returns:
+            Converted value if special type detected, original value otherwise.
+        """
+        if not isinstance(value, str):
+            return value
+
+        # Quick pre-check for performance - avoid regex on plain strings
+        if not any(c in value for c in ["{", "[", "-", ":", "T"]):
+            return value  # Skip regex entirely for "hello world" etc.
+
+        detected_type = self.detect_type(value)
+        if detected_type:
+            try:
+                return self.convert_value(value, detected_type)
+            except Exception:
+                # If conversion fails, return original value
+                return value
+        return value
+
+
+def convert_uuid(value: str) -> UUID:
+    """Convert UUID string to UUID object.
+
+    Args:
+        value: UUID string.
+
+    Returns:
+        UUID object.
+    """
+    return UUID(value)
+
+
+def convert_iso_datetime(value: str) -> datetime:
+    """Convert ISO 8601 datetime string to datetime object.
+
+    Args:
+        value: ISO datetime string.
+
+    Returns:
+        datetime object.
+    """
+    # Handle various ISO formats with timezone
+    if value.endswith("Z"):
+        value = value[:-1] + "+00:00"
+
+    # Replace space with T for standard ISO format
+    if " " in value and "T" not in value:
+        value = value.replace(" ", "T")
+
+    return datetime.fromisoformat(value)
+
+
+def convert_iso_date(value: str) -> date:
+    """Convert ISO date string to date object.
+
+    Args:
+        value: ISO date string.
+
+    Returns:
+        date object.
+    """
+    return date.fromisoformat(value)
+
+
+def convert_iso_time(value: str) -> time:
+    """Convert ISO time string to time object.
+
+    Args:
+        value: ISO time string.
+
+    Returns:
+        time object.
+    """
+    return time.fromisoformat(value)
+
+
+def convert_json(value: str) -> Any:
+    """Convert JSON string to Python object.
+
+    Args:
+        value: JSON string.
+
+    Returns:
+        Decoded Python object.
+    """
+    return decode_json(value)
+
+
+def convert_decimal(value: str) -> Decimal:
+    """Convert string to Decimal for precise arithmetic.
+
+    Args:
+        value: Decimal string.
+
+    Returns:
+        Decimal object.
+    """
+    return Decimal(value)
+
+
+# Converter registry
+_TYPE_CONVERTERS: Final[dict[str, Callable[[str], Any]]] = {
+    "uuid": convert_uuid,
+    "iso_datetime": convert_iso_datetime,
+    "iso_date": convert_iso_date,
+    "iso_time": convert_iso_time,
+    "json": convert_json,
+}
+
+
+def format_datetime_rfc3339(dt: datetime) -> str:
+    """Format datetime as RFC 3339 compliant string.
+
+    Args:
+        dt: datetime object.
+
+    Returns:
+        RFC 3339 formatted datetime string.
+    """
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt.isoformat()
+
+
+def parse_datetime_rfc3339(dt_str: str) -> datetime:
+    """Parse RFC 3339 datetime string.
+
+    Args:
+        dt_str: RFC 3339 datetime string.
+
+    Returns:
+        datetime object.
+    """
+    # Handle Z suffix
+    if dt_str.endswith("Z"):
+        dt_str = dt_str[:-1] + "+00:00"
+    return datetime.fromisoformat(dt_str)
+
+
+__all__ = (
+    "BaseTypeConverter",
+    "convert_decimal",
+    "convert_iso_date",
+    "convert_iso_datetime",
+    "convert_iso_time",
+    "convert_json",
+    "convert_uuid",
+    "format_datetime_rfc3339",
+    "parse_datetime_rfc3339",
+)

sqlspec/driver/__init__.py

@@ -3,16 +3,19 @@
 from typing import Union
 
 from sqlspec.driver import mixins
-from sqlspec.driver._async import AsyncDriverAdapterBase
-from sqlspec.driver._common import CommonDriverAttributesMixin, ExecutionResult
-from sqlspec.driver._sync import SyncDriverAdapterBase
+from sqlspec.driver._async import AsyncDataDictionaryBase, AsyncDriverAdapterBase
+from sqlspec.driver._common import CommonDriverAttributesMixin, ExecutionResult, VersionInfo
+from sqlspec.driver._sync import SyncDataDictionaryBase, SyncDriverAdapterBase
 
 __all__ = (
+    "AsyncDataDictionaryBase",
     "AsyncDriverAdapterBase",
     "CommonDriverAttributesMixin",
     "DriverAdapterProtocol",
     "ExecutionResult",
+    "SyncDataDictionaryBase",
     "SyncDriverAdapterBase",
+    "VersionInfo",
     "mixins",
 )