sqlspec 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

sqlspec/storage/registry.py

@@ -0,0 +1,315 @@
+"""Unified Storage Registry for ObjectStore backends.
+
+This module provides a flexible, lazy-loading storage registry that supports:
+- URI-first access pattern with automatic backend detection
+- ObStore preferred, FSSpec fallback architecture
+- Intelligent scheme-based routing with dependency detection
+- Named aliases for commonly used configurations (secondary feature)
+- Automatic instrumentation integration
+"""
+
+# TODO: TRY300 - Review try-except patterns for else block opportunities
+import logging
+from pathlib import Path
+from typing import Any, Optional, TypeVar, Union, cast
+
+from sqlspec.exceptions import ImproperConfigurationError, MissingDependencyError
+from sqlspec.storage.protocol import ObjectStoreProtocol
+from sqlspec.typing import FSSPEC_INSTALLED, OBSTORE_INSTALLED
+
+__all__ = ("StorageRegistry", "storage_registry")
+
+logger = logging.getLogger(__name__)
+
+BackendT = TypeVar("BackendT", bound=ObjectStoreProtocol)
+
+FSSPEC_ONLY_SCHEMES = {"http", "https", "ftp", "sftp", "ssh"}
+
+
+class StorageRegistry:
+    """Unified storage registry with URI-first access and intelligent backend selection.
+
+    This registry implements Phase 3 of the unified storage redesign:
+    - URI-first access pattern - pass URIs directly to get()
+    - Automatic ObStore preference when available
+    - Intelligent FSSpec fallback for unsupported schemes or when ObStore unavailable
+    - Named aliases as secondary feature for commonly used configurations
+    - Dependency-aware backend selection with clear error messages
+
+    Examples:
+        # Primary usage: Direct URI access (no registration needed)
+        backend = registry.get("s3://my-bucket/file.parquet")    # ObStore preferred
+        backend = registry.get("file:///tmp/data.csv")          # Obstore for local files
+        backend = registry.get("gs://bucket/data.json")         # ObStore for GCS
+
+        # Secondary usage: Named aliases for complex configurations
+        registry.register_alias(
+            "production-s3",
+            uri="s3://prod-bucket/data",
+            base_path="sqlspec",
+            aws_access_key_id="...",
+            aws_secret_access_key="..."
+        )
+        backend = registry.get("production-s3")  # Uses alias
+
+        # Automatic fallback when ObStore unavailable
+        # If obstore not installed: s3:// → FSSpec automatically
+        # Clear error if neither backend supports the scheme
+    """
+
+    def __init__(self) -> None:
+        # Named aliases (secondary feature) - internal storage
+        self._alias_configs: dict[str, tuple[type[ObjectStoreProtocol], str, dict[str, Any]]] = {}
+        # Expose configs for testing compatibility
+        self._aliases: dict[str, dict[str, Any]] = {}
+        self._instances: dict[Union[str, tuple[str, tuple[tuple[str, Any], ...]]], ObjectStoreProtocol] = {}
+
+    def register_alias(
+        self,
+        alias: str,
+        uri: str,
+        *,
+        backend: Optional[type[ObjectStoreProtocol]] = None,
+        base_path: str = "",
+        config: Optional[dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Register a named alias for a storage configuration.
+
+        Args:
+            alias: Unique alias name for the configuration
+            uri: Storage URI (e.g., "s3://bucket", "file:///path")
+            backend: Backend class to use (auto-detected from URI if not provided)
+            base_path: Base path to prepend to all operations
+            config: Additional configuration dict
+            **kwargs: Backend-specific configuration options
+        """
+        if backend is None:
+            # Auto-detect from URI using new intelligent selection
+            backend = self._determine_backend_class(uri)
+
+        config = config or {}
+        config.update(kwargs)
+
+        # Store the actual config that will be passed to backend
+        backend_config = dict(config)
+        if base_path:
+            backend_config["base_path"] = base_path
+
+        # Store backend class, URI, and config separately
+        self._alias_configs[alias] = (backend, uri, backend_config)
+
+        # Store config with URI for test compatibility
+        test_config = dict(backend_config)
+        test_config["uri"] = uri
+        self._aliases[alias] = test_config
+
+    def get(self, uri_or_alias: Union[str, Path], **kwargs: Any) -> ObjectStoreProtocol:
+        """Get backend instance using URI-first routing with intelligent backend selection.
+
+        Args:
+            uri_or_alias: URI to resolve directly OR named alias (secondary feature)
+            **kwargs: Additional backend-specific configuration options
+
+        Returns:
+            Backend instance with automatic ObStore preference and FSSpec fallback
+
+        Raises:
+            ImproperConfigurationError: If alias not found or invalid input
+        """
+        # Handle None case - raise AttributeError for test compatibility
+        if uri_or_alias is None:
+            msg = "uri_or_alias cannot be None"
+            raise AttributeError(msg)
+
+        # Handle empty string
+        if not uri_or_alias:
+            msg = "Unknown storage alias: ''"
+            raise ImproperConfigurationError(msg)
+
+        # Handle Path objects - convert to file:// URI
+        if isinstance(uri_or_alias, Path):
+            uri_or_alias = f"file://{uri_or_alias.resolve()}"
+
+        # Check cache first
+        cache_key: Union[str, tuple[str, tuple[tuple[str, Any], ...]]] = (
+            (uri_or_alias, tuple(sorted(kwargs.items()))) if kwargs else uri_or_alias
+        )
+        if cache_key in self._instances:
+            return self._instances[cache_key]
+
+        # PRIMARY: Try URI-first routing
+        if "://" in uri_or_alias:
+            backend = self._resolve_from_uri(uri_or_alias, **kwargs)
+            # Cache the instance for future use
+            self._instances[cache_key] = backend
+            return backend
+
+        # SECONDARY: Check if it's a registered alias
+        if uri_or_alias in self._alias_configs:
+            backend_cls, stored_uri, config = self._alias_configs[uri_or_alias]
+            # Merge kwargs with alias config (kwargs override)
+            merged_config = dict(config)
+            merged_config.update(kwargs)
+            # URI is passed as first positional arg
+            instance = backend_cls(stored_uri, **merged_config)
+            self._instances[cache_key] = instance
+            return instance
+
+        # Not a URI and not an alias
+        msg = f"Unknown storage alias: '{uri_or_alias}'"
+        raise ImproperConfigurationError(msg)
+
+    def _resolve_from_uri(self, uri: str, **kwargs: Any) -> ObjectStoreProtocol:
+        """Resolve backend from URI.
+
+        Tries ObStore first for supported schemes, then falls back to FSSpec.
+
+        Args:
+            uri: URI to resolve backend for
+            **kwargs: Additional backend-specific configuration
+
+        Returns:
+            Backend instance
+
+        Raises:
+            MissingDependencyError: If no suitable backend can be created
+        """
+        # Schemes that ObStore doesn't support
+
+        # Extract scheme
+        scheme = self._get_scheme(uri)
+
+        last_exc: Optional[Exception] = None
+
+        # If scheme is FSSpec-only, skip ObStore
+        if scheme not in FSSPEC_ONLY_SCHEMES and OBSTORE_INSTALLED:
+            try:
+                return self._create_backend("obstore", uri, **kwargs)
+            except (ImportError, ValueError) as e:
+                logger.debug("ObStore backend failed for %s: %s", uri, e)
+                last_exc = e
+
+        if FSSPEC_INSTALLED:
+            try:
+                return self._create_backend("fsspec", uri, **kwargs)
+            except (ImportError, ValueError) as e:
+                logger.debug("FSSpec backend failed for %s: %s", uri, e)
+                last_exc = e
+
+        msg = f"No storage backend available for URI '{uri}'. Install 'obstore' or 'fsspec' and ensure dependencies for your filesystem are installed."
+        raise MissingDependencyError(msg) from last_exc
+
+    def _determine_backend_class(self, uri: str) -> type[ObjectStoreProtocol]:
+        """Determine the best backend class for a URI based on availability.
+
+        Prefers ObStore, falls back to FSSpec.
+
+        Args:
+            uri: URI to determine backend for.
+
+        Returns:
+            Backend class (not instance)
+        """
+        if OBSTORE_INSTALLED:
+            return self._get_backend_class("obstore")
+        if FSSPEC_INSTALLED:
+            return self._get_backend_class("fsspec")
+
+        scheme = uri.split("://", maxsplit=1)[0].lower()
+        msg = f"No backend available for URI scheme '{scheme}'. Install obstore or fsspec."
+        raise MissingDependencyError(msg)
+
+    def _get_backend_class(self, backend_type: str) -> type[ObjectStoreProtocol]:
+        """Get backend class by type name.
+
+        Args:
+            backend_type: Backend type ('obstore' or 'fsspec')
+
+        Returns:
+            Backend class
+
+        Raises:
+            ValueError: If unknown backend type
+        """
+        if backend_type == "obstore":
+            from sqlspec.storage.backends.obstore import ObStoreBackend
+
+            return cast("type[ObjectStoreProtocol]", ObStoreBackend)
+        if backend_type == "fsspec":
+            from sqlspec.storage.backends.fsspec import FSSpecBackend
+
+            return cast("type[ObjectStoreProtocol]", FSSpecBackend)
+        msg = f"Unknown backend type: {backend_type}. Supported types: 'obstore', 'fsspec'"
+        raise ValueError(msg)
+
+    def _create_backend(self, backend_type: str, uri: str, **kwargs: Any) -> ObjectStoreProtocol:
+        """Create backend instance for URI.
+
+        Args:
+            backend_type: Backend type ('obstore' or 'fsspec')
+            uri: URI to create backend for
+            **kwargs: Additional backend-specific configuration
+
+        Returns:
+            Backend instance
+        """
+        backend_cls = self._get_backend_class(backend_type)
+        # Both backends accept URI as first positional parameter
+        return backend_cls(uri, **kwargs)
+
+    def _get_scheme(self, uri: str) -> str:
+        """Extract scheme from URI.
+
+        Args:
+            uri: URI to extract scheme from
+
+        Returns:
+            Scheme (e.g., 's3', 'gs', 'file')
+        """
+        # Handle file paths without explicit file:// scheme
+        if not uri or "://" not in uri:
+            # Local path (absolute or relative)
+            return "file"
+
+        # Extract scheme from URI
+        return uri.split("://", maxsplit=1)[0].lower()
+
+    # Utility methods
+    def is_alias_registered(self, alias: str) -> bool:
+        """Check if a named alias is registered."""
+        return alias in self._alias_configs
+
+    def list_aliases(self) -> list[str]:
+        """List all registered aliases."""
+        return list(self._alias_configs.keys())
+
+    def clear_cache(self, uri_or_alias: Optional[str] = None) -> None:
+        """Clear resolved backend cache.
+
+        Args:
+            uri_or_alias: Specific URI or alias to clear, or None to clear all
+        """
+        if uri_or_alias:
+            self._instances.pop(uri_or_alias, None)
+        else:
+            self._instances.clear()
+
+    def clear(self) -> None:
+        """Clear all aliases and instances."""
+        self._alias_configs.clear()
+        self._aliases.clear()
+        self._instances.clear()
+
+    def clear_instances(self) -> None:
+        """Clear only cached instances, keeping aliases."""
+        self._instances.clear()
+
+    def clear_aliases(self) -> None:
+        """Clear only aliases, keeping cached instances."""
+        self._alias_configs.clear()
+        self._aliases.clear()
+
+
+# Global registry instance
+storage_registry = StorageRegistry()

sqlspec/typing.py

@@ -1,32 +1,53 @@
+from collections.abc import Iterable, Mapping
+from collections.abc import Set as AbstractSet
 from dataclasses import Field, fields
 from functools import lru_cache
-from typing import TYPE_CHECKING, Annotated, Any, Optional, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Annotated, Any, Optional, Union, cast
 
-from typing_extensions import TypeAlias, TypeGuard
+from sqlglot import exp
+from typing_extensions import TypeAlias, TypeGuard, TypeVar
 
 from sqlspec._typing import (
+    AIOSQL_INSTALLED,
+    FSSPEC_INSTALLED,
     LITESTAR_INSTALLED,
     MSGSPEC_INSTALLED,
+    OBSTORE_INSTALLED,
+    OPENTELEMETRY_INSTALLED,
+    PGVECTOR_INSTALLED,
+    PROMETHEUS_INSTALLED,
     PYARROW_INSTALLED,
     PYDANTIC_INSTALLED,
     UNSET,
+    AiosqlAsyncProtocol,  # pyright: ignore[reportAttributeAccessIssue]
+    AiosqlParamType,  # pyright: ignore[reportAttributeAccessIssue]
+    AiosqlProtocol,  # pyright: ignore[reportAttributeAccessIssue]
+    AiosqlSQLOperationType,  # pyright: ignore[reportAttributeAccessIssue]
+    AiosqlSyncProtocol,  # pyright: ignore[reportAttributeAccessIssue]
+    ArrowRecordBatch,
     ArrowTable,
     BaseModel,
+    Counter,  # pyright: ignore[reportAttributeAccessIssue]
     DataclassProtocol,
     DTOData,
     Empty,
     EmptyType,
+    Gauge,  # pyright: ignore[reportAttributeAccessIssue]
+    Histogram,  # pyright: ignore[reportAttributeAccessIssue]
+    Span,  # pyright: ignore[reportAttributeAccessIssue]
+    Status,  # pyright: ignore[reportAttributeAccessIssue]
+    StatusCode,  # pyright: ignore[reportAttributeAccessIssue]
     Struct,
+    Tracer,  # pyright: ignore[reportAttributeAccessIssue]
     TypeAdapter,
     UnsetType,
-    convert,
+    aiosql,
+    convert,  # pyright: ignore[reportAttributeAccessIssue]
+    trace,
 )
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Sequence
-    from collections.abc import Set as AbstractSet
-
-    from sqlspec.filters import StatementFilter
 
 
 PYDANTIC_USE_FAILFAST = False  # leave permanently disabled for now
@@ -54,16 +75,29 @@ ModelT = TypeVar("ModelT", bound="Union[dict[str, Any], Struct, BaseModel, Datac
 :class:`dict[str, Any]` | :class:`msgspec.Struct` | :class:`pydantic.BaseModel` | :class:`DataclassProtocol`
 """
 
-FilterTypeT = TypeVar("FilterTypeT", bound="StatementFilter")
-"""Type variable for filter types.
 
-:class:`~advanced_alchemy.filters.StatementFilter`
-"""
+DictRow: TypeAlias = "dict[str, Any]"
+"""Type variable for DictRow types."""
+TupleRow: TypeAlias = "tuple[Any, ...]"
+"""Type variable for TupleRow types."""
+RowT = TypeVar("RowT", default=dict[str, Any])
+
 SupportedSchemaModel: TypeAlias = "Union[Struct, BaseModel, DataclassProtocol]"
 """Type alias for pydantic or msgspec models.
 
 :class:`msgspec.Struct` | :class:`pydantic.BaseModel` | :class:`DataclassProtocol`
 """
+StatementParameters: TypeAlias = "Union[Any, dict[str, Any], list[Any], tuple[Any, ...], None]"
+"""Type alias for statement parameters.
+
+Represents:
+- :type:`dict[str, Any]`
+- :type:`list[Any]`
+- :type:`tuple[Any, ...]`
+- :type:`None`
+"""
+# Backward compatibility alias
+SQLParameterType: TypeAlias = StatementParameters
 ModelDTOT = TypeVar("ModelDTOT", bound="SupportedSchemaModel")
 """Type variable for model DTOs.
 
@@ -97,18 +131,8 @@ Represents:
 - :class:`DTOData`[:type:`list[ModelT]`]
 """
 
-StatementParameterType: TypeAlias = "Union[Any, dict[str, Any], list[Any], tuple[Any, ...], None]"
-"""Type alias for parameter types.
-
-Represents:
-- :type:`dict[str, Any]`
-- :type:`list[Any]`
-- :type:`tuple[Any, ...]`
-- :type:`None`
-"""
-
 
-def is_dataclass_instance(obj: Any) -> "TypeGuard[DataclassProtocol]":
+def is_dataclass_instance(obj: Any) -> TypeGuard[DataclassProtocol]:
     """Check if an object is a dataclass instance.
 
     Args:
@@ -117,7 +141,9 @@ def is_dataclass_instance(obj: Any) -> "TypeGuard[DataclassProtocol]":
     Returns:
         True if the object is a dataclass instance.
     """
-    return hasattr(type(obj), "__dataclass_fields__")  # pyright: ignore[reportUnknownArgumentType]
+    # Ensure obj is an instance and not the class itself,
+    # and that its type is a dataclass.
+    return not isinstance(obj, type) and hasattr(type(obj), "__dataclass_fields__")
 
 
 @lru_cache(typed=True)
@@ -131,9 +157,7 @@ def get_type_adapter(f: "type[T]") -> "TypeAdapter[T]":
         :class:`pydantic.TypeAdapter`[:class:`typing.TypeVar`[T]]
     """
     if PYDANTIC_USE_FAILFAST:
-        return TypeAdapter(
-            Annotated[f, FailFast()],
-        )
+        return TypeAdapter(Annotated[f, FailFast()])
     return TypeAdapter(f)
 
 
@@ -302,8 +326,7 @@ def is_schema_without_field(obj: "Any", field_name: str) -> "TypeGuard[Supported
 
 
 def is_schema_or_dict_with_field(
-    obj: "Any",
-    field_name: str,
+    obj: "Any", field_name: str
 ) -> "TypeGuard[Union[SupportedSchemaModel, dict[str, Any]]]":
     """Check if a value is a msgspec Struct, Pydantic model, or dict with a specific field.
 
@@ -318,8 +341,7 @@ def is_schema_or_dict_with_field(
 
 
 def is_schema_or_dict_without_field(
-    obj: "Any",
-    field_name: str,
+    obj: "Any", field_name: str
 ) -> "TypeGuard[Union[SupportedSchemaModel, dict[str, Any]]]":
     """Check if a value is a msgspec Struct, Pydantic model, or dict without a specific field.
 
@@ -342,12 +364,13 @@ def is_dataclass(obj: "Any") -> "TypeGuard[DataclassProtocol]":
     Returns:
         bool
     """
+    if isinstance(obj, type) and hasattr(obj, "__dataclass_fields__"):
+        return True
     return is_dataclass_instance(obj)
 
 
 def is_dataclass_with_field(
-    obj: "Any",
-    field_name: str,
+    obj: "Any", field_name: str
 ) -> "TypeGuard[object]":  # Can't specify dataclass type directly
     """Check if an object is a dataclass and has a specific field.
 
@@ -475,8 +498,7 @@ def dataclass_to_dict(
 
 
 def schema_dump(
-    data: "Union[dict[str, Any],   DataclassProtocol, Struct, BaseModel]",
-    exclude_unset: bool = True,
+    data: "Union[dict[str, Any],   DataclassProtocol, Struct, BaseModel]", exclude_unset: bool = True
 ) -> "dict[str, Any]":
     """Dump a data object to a dictionary.
 
@@ -515,27 +537,85 @@ def is_dto_data(v: Any) -> TypeGuard[DTOData[Any]]:
     return LITESTAR_INSTALLED and isinstance(v, DTOData)
 
 
+def is_expression(obj: "Any") -> "TypeGuard[exp.Expression]":
+    """Check if a value is a sqlglot Expression.
+
+    Args:
+        obj: Value to check.
+
+    Returns:
+        bool
+    """
+    return isinstance(obj, exp.Expression)
+
+
+def MixinOf(base: type[T]) -> type[T]:  # noqa: N802
+    """Useful function to make mixins with baseclass type hint
+
+    ```
+    class StorageMixin(MixinOf(DriverProtocol)): ...
+    ```
+    """
+    if TYPE_CHECKING:
+        return base
+    return type("<MixinOf>", (base,), {})
+
+
 __all__ = (
+    "AIOSQL_INSTALLED",
+    "FSSPEC_INSTALLED",
     "LITESTAR_INSTALLED",
     "MSGSPEC_INSTALLED",
+    "OBSTORE_INSTALLED",
+    "OPENTELEMETRY_INSTALLED",
+    "PGVECTOR_INSTALLED",
+    "PROMETHEUS_INSTALLED",
     "PYARROW_INSTALLED",
     "PYDANTIC_INSTALLED",
     "PYDANTIC_USE_FAILFAST",
     "UNSET",
+    "AiosqlAsyncProtocol",
+    "AiosqlParamType",
+    "AiosqlProtocol",
+    "AiosqlSQLOperationType",
+    "AiosqlSyncProtocol",
+    "ArrowRecordBatch",
     "ArrowTable",
     "BaseModel",
+    "BulkModelDict",
+    "ConnectionT",
+    "Counter",
     "DataclassProtocol",
+    "DictRow",
     "Empty",
     "EmptyType",
     "FailFast",
-    "FilterTypeT",
+    "Gauge",
+    "Histogram",
+    "Mapping",
+    "MixinOf",
+    "ModelDTOT",
+    "ModelDict",
     "ModelDict",
     "ModelDictList",
-    "StatementParameterType",
+    "ModelDictList",
+    "ModelT",
+    "PoolT",
+    "PoolT_co",
+    "PydanticOrMsgspecT",
+    "RowT",
+    "SQLParameterType",
+    "Span",
+    "StatementParameters",
+    "Status",
+    "StatusCode",
     "Struct",
     "SupportedSchemaModel",
+    "Tracer",
+    "TupleRow",
     "TypeAdapter",
     "UnsetType",
+    "aiosql",
     "convert",
     "dataclass_to_dict",
     "extract_dataclass_fields",
@@ -549,6 +629,7 @@ __all__ = (
     "is_dict_with_field",
     "is_dict_without_field",
     "is_dto_data",
+    "is_expression",
     "is_msgspec_struct",
     "is_msgspec_struct_with_field",
     "is_msgspec_struct_without_field",
@@ -562,6 +643,7 @@ __all__ = (
     "is_schema_with_field",
     "is_schema_without_field",
     "schema_dump",
+    "trace",
 )
 
 if TYPE_CHECKING:
@@ -576,10 +658,49 @@ if TYPE_CHECKING:
         from msgspec import UNSET, Struct, UnsetType, convert  # noqa: TC004
 
     if not PYARROW_INSTALLED:
-        from sqlspec._typing import ArrowTable
+        from sqlspec._typing import ArrowRecordBatch, ArrowTable
     else:
+        from pyarrow import RecordBatch as ArrowRecordBatch  # noqa: TC004
         from pyarrow import Table as ArrowTable  # noqa: TC004
     if not LITESTAR_INSTALLED:
         from sqlspec._typing import DTOData
     else:
         from litestar.dto import DTOData  # noqa: TC004
+    if not OPENTELEMETRY_INSTALLED:
+        from sqlspec._typing import Span, Status, StatusCode, Tracer, trace  # noqa: TC004  # pyright: ignore
+    else:
+        from opentelemetry.trace import (  # pyright: ignore[reportMissingImports] # noqa: TC004
+            Span,
+            Status,
+            StatusCode,
+            Tracer,
+        )
+    if not PROMETHEUS_INSTALLED:
+        from sqlspec._typing import Counter, Gauge, Histogram  # pyright: ignore
+    else:
+        from prometheus_client import Counter, Gauge, Histogram  # noqa: TC004 # pyright: ignore # noqa: TC004
+
+    if not AIOSQL_INSTALLED:
+        from sqlspec._typing import (
+            AiosqlAsyncProtocol,  # pyright: ignore[reportAttributeAccessIssue]
+            AiosqlParamType,  # pyright: ignore[reportAttributeAccessIssue]
+            AiosqlProtocol,  # pyright: ignore[reportAttributeAccessIssue]
+            AiosqlSQLOperationType,  # pyright: ignore[reportAttributeAccessIssue]
+            AiosqlSyncProtocol,  # pyright: ignore[reportAttributeAccessIssue]
+            aiosql,
+        )
+    else:
+        import aiosql  # noqa: TC004 # pyright: ignore
+        from aiosql.types import (  # noqa: TC004 # pyright: ignore[reportMissingImports]
+            AsyncDriverAdapterProtocol as AiosqlAsyncProtocol,
+        )
+        from aiosql.types import (  # noqa: TC004 # pyright: ignore[reportMissingImports]
+            DriverAdapterProtocol as AiosqlProtocol,
+        )
+        from aiosql.types import ParamType as AiosqlParamType  # noqa: TC004 # pyright: ignore[reportMissingImports]
+        from aiosql.types import (
+            SQLOperationType as AiosqlSQLOperationType,  # noqa: TC004 # pyright: ignore[reportMissingImports]
+        )
+        from aiosql.types import (  # noqa: TC004 # pyright: ignore[reportMissingImports]
+            SyncDriverAdapterProtocol as AiosqlSyncProtocol,
+        )