sqlspec 0.36.0__cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl

sqlspec/adapters/spanner/config.py

@@ -0,0 +1,352 @@
+"""Spanner configuration."""
+
+from typing import TYPE_CHECKING, Any, ClassVar, TypedDict, cast
+
+from google.cloud.spanner_v1 import Client
+from google.cloud.spanner_v1.pool import AbstractSessionPool, FixedSizePool
+from typing_extensions import NotRequired
+
+from sqlspec.adapters.spanner._typing import SpannerConnection
+from sqlspec.adapters.spanner.core import apply_driver_features, default_statement_config
+from sqlspec.adapters.spanner.driver import SpannerSessionContext, SpannerSyncDriver
+from sqlspec.config import SyncDatabaseConfig
+from sqlspec.exceptions import ImproperConfigurationError
+from sqlspec.extensions.events import EventRuntimeHints
+from sqlspec.utils.config_tools import normalize_connection_config, reject_pool_aliases
+from sqlspec.utils.type_guards import supports_close
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from google.auth.credentials import Credentials
+    from google.cloud.spanner_v1.database import Database
+
+    from sqlspec.config import ExtensionConfigs
+    from sqlspec.core import StatementConfig
+    from sqlspec.observability import ObservabilityConfig
+
+__all__ = ("SpannerConnectionParams", "SpannerDriverFeatures", "SpannerPoolParams", "SpannerSyncConfig")
+
+
+class SpannerConnectionParams(TypedDict):
+    """Spanner connection parameters."""
+
+    project: "NotRequired[str]"
+    instance_id: "NotRequired[str]"
+    database_id: "NotRequired[str]"
+    credentials: "NotRequired[Credentials]"
+    client_options: "NotRequired[dict[str, Any]]"
+    extra: "NotRequired[dict[str, Any]]"
+
+
+class SpannerPoolParams(SpannerConnectionParams):
+    """Session pool configuration."""
+
+    pool_type: "NotRequired[type[AbstractSessionPool]]"
+    min_sessions: "NotRequired[int]"
+    max_sessions: "NotRequired[int]"
+    labels: "NotRequired[dict[str, str]]"
+    ping_interval: "NotRequired[int]"
+
+
+class SpannerDriverFeatures(TypedDict):
+    """Driver feature flags for Spanner.
+
+    Attributes:
+        enable_uuid_conversion: Enable automatic UUID string conversion.
+        json_serializer: Custom JSON serializer for parameter conversion.
+        json_deserializer: Custom JSON deserializer for result conversion.
+        session_labels: Labels to apply to Spanner sessions.
+        enable_events: Enable database event channel support.
+            Defaults to True when extension_config["events"] is configured.
+        events_backend: Backend type for event handling.
+            Spanner only supports "table_queue" (no native pub/sub).
+    """
+
+    enable_uuid_conversion: "NotRequired[bool]"
+    json_serializer: "NotRequired[Callable[[Any], str]]"
+    json_deserializer: "NotRequired[Callable[[str], Any]]"
+    session_labels: "NotRequired[dict[str, str]]"
+    enable_events: "NotRequired[bool]"
+    events_backend: "NotRequired[str]"
+
+
+class SpannerConnectionContext:
+    """Context manager for Spanner connections."""
+
+    __slots__ = ("_config", "_connection", "_session", "_transaction")
+
+    def __init__(self, config: "SpannerSyncConfig", transaction: bool = False) -> None:
+        self._config = config
+        self._transaction = transaction
+        self._connection: SpannerConnection | None = None
+        self._session: Any = None
+
+    def __enter__(self) -> SpannerConnection:
+        database = self._config.get_database()
+        if self._transaction:
+            self._session = cast("Any", database).session()
+            self._session.create()
+            try:
+                txn = self._session.transaction()
+                txn.__enter__()
+                self._connection = cast("SpannerConnection", txn)
+            except Exception:
+                self._session.delete()
+                raise
+            else:
+                return self._connection
+        else:
+            self._session = cast("Any", database).snapshot(multi_use=True)
+            self._connection = cast("SpannerConnection", self._session.__enter__())
+            return self._connection
+
+    def __exit__(
+        self, exc_type: "type[BaseException] | None", exc_val: "BaseException | None", exc_tb: Any
+    ) -> bool | None:
+        if self._transaction and self._connection:
+            txn = cast("Any", self._connection)
+            try:
+                if exc_type is None:
+                    try:
+                        txn_id = txn._transaction_id
+                    except AttributeError:
+                        txn_id = None
+                    try:
+                        committed = txn.committed
+                    except AttributeError:
+                        committed = None
+                    if txn_id is not None and committed is None:
+                        txn.commit()
+                else:
+                    try:
+                        rollback_txn_id = txn._transaction_id
+                    except AttributeError:
+                        rollback_txn_id = None
+                    if rollback_txn_id is not None:
+                        txn.rollback()
+            finally:
+                if self._session:
+                    self._session.delete()
+        elif self._session:
+            self._session.__exit__(exc_type, exc_val, exc_tb)
+
+        self._connection = None
+        self._session = None
+        return None
+
+
+class _SpannerSessionConnectionHandler:
+    __slots__ = ("_connection_ctx",)
+
+    def __init__(self, connection_ctx: "SpannerConnectionContext") -> None:
+        self._connection_ctx = connection_ctx
+
+    def acquire_connection(self) -> "SpannerConnection":
+        return self._connection_ctx.__enter__()
+
+    def release_connection(
+        self,
+        _conn: "SpannerConnection",
+        exc_type: "type[BaseException] | None",
+        exc_val: "BaseException | None",
+        exc_tb: Any,
+    ) -> None:
+        self._connection_ctx.__exit__(exc_type, exc_val, exc_tb)
+
+
+class SpannerSyncConfig(SyncDatabaseConfig["SpannerConnection", "AbstractSessionPool", SpannerSyncDriver]):
+    """Spanner configuration and session management."""
+
+    driver_type: ClassVar[type["SpannerSyncDriver"]] = SpannerSyncDriver
+    connection_type: ClassVar[type["SpannerConnection"]] = cast("type[SpannerConnection]", SpannerConnection)
+    supports_transactional_ddl: ClassVar[bool] = False
+    supports_native_arrow_export: ClassVar[bool] = True
+    supports_native_arrow_import: ClassVar[bool] = True
+    supports_native_parquet_export: ClassVar[bool] = False
+    supports_native_parquet_import: ClassVar[bool] = False
+    requires_staging_for_load: ClassVar[bool] = False
+
+    def __init__(
+        self,
+        *,
+        connection_config: "SpannerPoolParams | dict[str, Any] | None" = None,
+        connection_instance: "AbstractSessionPool | None" = None,
+        migration_config: "dict[str, Any] | None" = None,
+        statement_config: "StatementConfig | None" = None,
+        driver_features: "SpannerDriverFeatures | dict[str, Any] | None" = None,
+        bind_key: "str | None" = None,
+        extension_config: "ExtensionConfigs | None" = None,
+        observability_config: "ObservabilityConfig | None" = None,
+        **kwargs: Any,
+    ) -> None:
+        reject_pool_aliases(kwargs)
+
+        self.connection_config = normalize_connection_config(connection_config)
+
+        self.connection_config.setdefault("min_sessions", 1)
+        self.connection_config.setdefault("max_sessions", 10)
+        self.connection_config.setdefault("pool_type", FixedSizePool)
+
+        driver_features = apply_driver_features(driver_features)
+
+        statement_config = statement_config or default_statement_config
+
+        super().__init__(
+            connection_config=self.connection_config,
+            connection_instance=connection_instance,
+            migration_config=migration_config,
+            statement_config=statement_config,
+            driver_features=driver_features,
+            bind_key=bind_key,
+            extension_config=extension_config,
+            observability_config=observability_config,
+            **kwargs,
+        )
+
+        self._client: Client | None = None
+        self._database: Database | None = None
+
+    def _get_client(self) -> Client:
+        if self._client is None:
+            self._client = Client(
+                project=self.connection_config.get("project"),
+                credentials=self.connection_config.get("credentials"),
+                client_options=self.connection_config.get("client_options"),
+            )
+        return self._client
+
+    def get_database(self) -> "Database":
+        instance_id = self.connection_config.get("instance_id")
+        database_id = self.connection_config.get("database_id")
+        if not instance_id or not database_id:
+            msg = "instance_id and database_id are required."
+            raise ImproperConfigurationError(msg)
+
+        if self.connection_instance is None:
+            self.connection_instance = self.provide_pool()
+
+        if self._database is None:
+            client = self._get_client()
+            self._database = client.instance(instance_id).database(database_id, pool=self.connection_instance)  # type: ignore[no-untyped-call]
+        return self._database
+
+    def create_connection(self) -> SpannerConnection:
+        instance_id = self.connection_config.get("instance_id")
+        database_id = self.connection_config.get("database_id")
+        if not instance_id or not database_id:
+            msg = "instance_id and database_id are required."
+            raise ImproperConfigurationError(msg)
+
+        if self.connection_instance is None:
+            self.connection_instance = self.provide_pool()
+
+        client = self._get_client()
+        database = client.instance(instance_id).database(database_id, pool=self.connection_instance)  # type: ignore[no-untyped-call]
+        return cast("SpannerConnection", database.snapshot())
+
+    def _create_pool(self) -> AbstractSessionPool:
+        instance_id = self.connection_config.get("instance_id")
+        database_id = self.connection_config.get("database_id")
+        if not instance_id or not database_id:
+            msg = "instance_id and database_id are required."
+            raise ImproperConfigurationError(msg)
+
+        pool_type = cast("type[AbstractSessionPool]", self.connection_config.get("pool_type", FixedSizePool))
+
+        pool_kwargs: dict[str, Any] = {}
+        if pool_type is FixedSizePool:
+            if "size" in self.connection_config:
+                pool_kwargs["size"] = self.connection_config["size"]
+            elif "max_sessions" in self.connection_config:
+                pool_kwargs["size"] = self.connection_config["max_sessions"]
+            if "labels" in self.connection_config:
+                pool_kwargs["labels"] = self.connection_config["labels"]
+        else:
+            valid_pool_keys = {"size", "labels", "ping_interval"}
+            pool_kwargs = {k: v for k, v in self.connection_config.items() if k in valid_pool_keys and v is not None}
+            if "size" not in pool_kwargs and "max_sessions" in self.connection_config:
+                pool_kwargs["size"] = self.connection_config["max_sessions"]
+
+        pool_factory = cast("Callable[..., AbstractSessionPool]", pool_type)
+        return pool_factory(**pool_kwargs)
+
+    def _close_pool(self) -> None:
+        if self.connection_instance and supports_close(self.connection_instance):
+            self.connection_instance.close()
+
+    def provide_connection(self, *args: Any, transaction: "bool" = False, **kwargs: Any) -> "SpannerConnectionContext":
+        """Yield a Snapshot (default) or Transaction context from the configured pool.
+
+        Args:
+            *args: Additional positional arguments (unused, for interface compatibility).
+            transaction: If True, yields a Transaction context that supports
+                execute_update() for DML statements. If False (default), yields
+                a read-only Snapshot context for SELECT queries.
+            **kwargs: Additional keyword arguments (unused, for interface compatibility).
+        """
+        return SpannerConnectionContext(self, transaction=transaction)
+
+    def provide_session(
+        self, *args: Any, statement_config: "StatementConfig | None" = None, transaction: "bool" = False, **kwargs: Any
+    ) -> "SpannerSessionContext":
+        """Provide a Spanner driver session context manager.
+
+        Args:
+            *args: Additional arguments.
+            statement_config: Optional statement configuration override.
+            transaction: Whether to use a transaction.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            A Spanner driver session context manager.
+        """
+        connection_ctx = SpannerConnectionContext(self, transaction=transaction)
+        handler = _SpannerSessionConnectionHandler(connection_ctx)
+
+        return SpannerSessionContext(
+            acquire_connection=handler.acquire_connection,
+            release_connection=handler.release_connection,
+            statement_config=statement_config or self.statement_config or default_statement_config,
+            driver_features=self.driver_features,
+            prepare_driver=self._prepare_driver,
+        )
+
+    def provide_write_session(
+        self, *args: Any, statement_config: "StatementConfig | None" = None, **kwargs: Any
+    ) -> "SpannerSessionContext":
+        """Provide a Spanner driver write session context manager.
+
+        Args:
+            *args: Additional arguments.
+            statement_config: Optional statement configuration override.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            A Spanner driver write session context manager.
+        """
+        return self.provide_session(*args, statement_config=statement_config, transaction=True, **kwargs)
+
+    def get_signature_namespace(self) -> "dict[str, Any]":
+        """Get the signature namespace for SpannerSyncConfig types.
+
+        Returns:
+            Dictionary mapping type names to types.
+        """
+        namespace = super().get_signature_namespace()
+        namespace.update({
+            "SpannerConnectionContext": SpannerConnectionContext,
+            "SpannerConnection": SpannerConnection,
+            "SpannerConnectionParams": SpannerConnectionParams,
+            "SpannerDriverFeatures": SpannerDriverFeatures,
+            "SpannerPoolParams": SpannerPoolParams,
+            "SpannerSessionContext": SpannerSessionContext,
+            "SpannerSyncConfig": SpannerSyncConfig,
+            "SpannerSyncDriver": SpannerSyncDriver,
+        })
+        return namespace
+
+    def get_event_runtime_hints(self) -> "EventRuntimeHints":
+        """Return queue defaults for Spanner JSON handling."""
+
+        return EventRuntimeHints(json_passthrough=True)

sqlspec/adapters/spanner/core.py

@@ -0,0 +1,188 @@
+"""Spanner adapter compiled helpers."""
+
+from typing import TYPE_CHECKING, Any
+
+from google.api_core import exceptions as api_exceptions
+
+from sqlspec.adapters.spanner.type_converter import coerce_params_for_spanner, infer_spanner_param_types
+from sqlspec.core import DriverParameterProfile, ParameterStyle, StatementConfig, build_statement_config_from_profile
+from sqlspec.exceptions import (
+    DatabaseConnectionError,
+    NotFoundError,
+    OperationalError,
+    SQLParsingError,
+    SQLSpecError,
+    UniqueViolationError,
+)
+from sqlspec.utils.arrow_helpers import convert_dict_to_arrow
+from sqlspec.utils.serializers import from_json, to_json
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping, Sequence
+
+    from sqlspec.typing import ArrowRecordBatch, ArrowRecordBatchReader, ArrowReturnFormat, ArrowTable
+
+__all__ = (
+    "apply_driver_features",
+    "build_profile",
+    "build_statement_config",
+    "coerce_params",
+    "collect_rows",
+    "create_arrow_data",
+    "create_mapped_exception",
+    "default_statement_config",
+    "driver_profile",
+    "infer_param_types",
+    "supports_batch_update",
+    "supports_write",
+)
+
+
+def build_profile() -> "DriverParameterProfile":
+    """Create the Spanner driver parameter profile."""
+
+    return DriverParameterProfile(
+        name="Spanner",
+        default_style=ParameterStyle.NAMED_AT,
+        supported_styles={ParameterStyle.NAMED_AT},
+        default_execution_style=ParameterStyle.NAMED_AT,
+        supported_execution_styles={ParameterStyle.NAMED_AT},
+        has_native_list_expansion=True,
+        json_serializer_strategy="none",
+        default_dialect="spanner",
+        preserve_parameter_format=True,
+        needs_static_script_compilation=False,
+        allow_mixed_parameter_styles=False,
+        preserve_original_params_for_many=True,
+        custom_type_coercions=None,
+        extras={},
+    )
+
+
+driver_profile = build_profile()
+
+
+def build_statement_config() -> StatementConfig:
+    """Construct the Spanner statement configuration."""
+    profile = driver_profile
+    return build_statement_config_from_profile(profile, statement_overrides={"dialect": "spanner"})
+
+
+default_statement_config = build_statement_config()
+
+
+def apply_driver_features(driver_features: "Mapping[str, Any] | None") -> "dict[str, Any]":
+    """Apply Spanner driver feature defaults."""
+    processed_features: dict[str, Any] = dict(driver_features) if driver_features else {}
+    processed_features.setdefault("enable_uuid_conversion", True)
+    processed_features.setdefault("json_serializer", to_json)
+    processed_features.setdefault("json_deserializer", from_json)
+    return processed_features
+
+
+def supports_write(cursor: Any) -> bool:
+    """Return True when the cursor supports DML execution."""
+    try:
+        _ = cursor.execute_update
+    except AttributeError:
+        return False
+    return True
+
+
+def supports_batch_update(cursor: Any) -> bool:
+    """Return True when the cursor supports batch updates."""
+    try:
+        _ = cursor.batch_update
+    except AttributeError:
+        return False
+    return True
+
+
+def infer_param_types(params: "dict[str, Any] | list[Any] | tuple[Any, ...] | None") -> "dict[str, Any]":
+    """Infer Spanner param_types from Python values."""
+    if not isinstance(params, dict):
+        return {}
+    return infer_spanner_param_types(params)
+
+
+def coerce_params(
+    params: "dict[str, Any] | list[Any] | tuple[Any, ...] | None",
+    *,
+    json_serializer: "Callable[[Any], str] | None" = None,
+) -> "dict[str, Any] | None":
+    """Coerce Python types to Spanner-compatible formats."""
+    if not isinstance(params, dict):
+        return None
+    return coerce_params_for_spanner(params, json_serializer=json_serializer)
+
+
+def collect_rows(
+    rows: "Sequence[Any]", fields: "Sequence[Any]", converter: Any
+) -> "tuple[list[dict[str, Any]], list[str]]":
+    """Collect Spanner rows into dictionaries.
+
+    Args:
+        rows: Rows from result set.
+        fields: Result set fields metadata.
+        converter: Type converter for row values.
+
+    Returns:
+        Tuple of (rows, column_names).
+    """
+    column_names = [field.name for field in fields]
+    data: list[dict[str, Any]] = []
+    for row in rows:
+        item: dict[str, Any] = {}
+        for index, column in enumerate(column_names):
+            item[column] = converter.convert_if_detected(row[index])
+        data.append(item)
+    return data, column_names
+
+
+def create_arrow_data(
+    data: "list[dict[str, Any]]", return_format: "ArrowReturnFormat"
+) -> "ArrowTable | ArrowRecordBatch | ArrowRecordBatchReader | list[ArrowRecordBatch]":
+    """Create Arrow data from Spanner row dictionaries.
+
+    Args:
+        data: Row dictionaries from Spanner results.
+        return_format: Arrow return format.
+
+    Returns:
+        Arrow data in the requested format.
+    """
+    return convert_dict_to_arrow(data, return_format=return_format)
+
+
+def _create_spanner_error(error: Any, error_class: type[SQLSpecError], description: str) -> SQLSpecError:
+    """Create a Spanner error instance without raising it."""
+    msg = f"Spanner {description}: {error}"
+    exc = error_class(msg)
+    exc.__cause__ = error
+    return exc
+
+
+def create_mapped_exception(error: Any) -> SQLSpecError:
+    """Map Spanner exceptions to SQLSpec exceptions.
+
+    This is a factory function that returns an exception instance rather than
+    raising. This pattern is more robust for use in __exit__ handlers and
+    avoids issues with exception control flow in different Python versions.
+
+    Args:
+        error: The Spanner exception to map
+
+    Returns:
+        A SQLSpec exception that wraps the original error
+    """
+    if isinstance(error, api_exceptions.AlreadyExists):
+        return _create_spanner_error(error, UniqueViolationError, "resource already exists")
+    if isinstance(error, api_exceptions.NotFound):
+        return _create_spanner_error(error, NotFoundError, "resource not found")
+    if isinstance(error, api_exceptions.InvalidArgument):
+        return _create_spanner_error(error, SQLParsingError, "invalid query or argument")
+    if isinstance(error, api_exceptions.PermissionDenied):
+        return _create_spanner_error(error, DatabaseConnectionError, "permission denied")
+    if isinstance(error, (api_exceptions.ServiceUnavailable, api_exceptions.TooManyRequests)):
+        return _create_spanner_error(error, OperationalError, "service unavailable or rate limited")
+    return _create_spanner_error(error, SQLSpecError, "error")

sqlspec/adapters/spanner/data_dictionary.py

@@ -0,0 +1,120 @@
+"""Spanner metadata queries using INFORMATION_SCHEMA."""
+
+from typing import TYPE_CHECKING, ClassVar
+
+from mypy_extensions import mypyc_attr
+
+from sqlspec.driver import SyncDataDictionaryBase
+from sqlspec.typing import ColumnMetadata, ForeignKeyMetadata, IndexMetadata, TableMetadata, VersionInfo
+
+__all__ = ("SpannerDataDictionary",)
+
+if TYPE_CHECKING:
+    from sqlspec.adapters.spanner.driver import SpannerSyncDriver
+
+
+@mypyc_attr(allow_interpreted_subclasses=True, native_class=False)
+class SpannerDataDictionary(SyncDataDictionaryBase):
+    """Fetch table, column, and index metadata from Spanner."""
+
+    dialect: ClassVar[str] = "spanner"
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def get_version(self, driver: "SpannerSyncDriver") -> "VersionInfo | None":
+        """Get Spanner version information.
+
+        Args:
+            driver: Spanner driver instance.
+
+        Returns:
+            None since Spanner does not expose version information.
+
+        """
+        _ = driver
+        return None
+
+    def get_feature_flag(self, driver: "SpannerSyncDriver", feature: str) -> bool:
+        """Check if Spanner supports a specific feature.
+
+        Args:
+            driver: Spanner driver instance.
+            feature: Feature name to check.
+
+        Returns:
+            True if feature is supported, False otherwise.
+
+        """
+        _ = driver
+        return self.resolve_feature_flag(feature, None)
+
+    def get_optimal_type(self, driver: "SpannerSyncDriver", type_category: str) -> str:
+        """Get optimal Spanner type for a category.
+
+        Args:
+            driver: Spanner driver instance.
+            type_category: Type category.
+
+        Returns:
+            Spanner-specific type name.
+
+        """
+        _ = driver
+        return self.get_dialect_config().get_optimal_type(type_category)
+
+    def get_tables(self, driver: "SpannerSyncDriver", schema: "str | None" = None) -> "list[TableMetadata]":
+        """Get tables using INFORMATION_SCHEMA."""
+        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: "SpannerSyncDriver", 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: "SpannerSyncDriver", 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: "SpannerSyncDriver", 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/spanner/dialect/__init__.py

@@ -0,0 +1,6 @@
+"""Spanner dialect submodule."""
+
+from sqlspec.adapters.spanner.dialect._spangres import Spangres
+from sqlspec.adapters.spanner.dialect._spanner import Spanner
+
+__all__ = ("Spangres", "Spanner")