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

sqlspec/adapters/duckdb/type_converter.py

@@ -0,0 +1,118 @@
+"""DuckDB-specific type conversion with native UUID support.
+
+Provides specialized type handling for DuckDB, including native UUID
+support and standardized datetime formatting.
+"""
+
+from datetime import datetime
+from typing import Any, Final
+from uuid import UUID
+
+from sqlspec.core.type_converter import CachedOutputConverter, convert_uuid, format_datetime_rfc3339
+
+__all__ = ("DUCKDB_SPECIAL_CHARS", "DuckDBOutputConverter")
+
+DUCKDB_SPECIAL_CHARS: Final[frozenset[str]] = frozenset({"-", ":", "T", ".", "[", "{"})
+
+
+class DuckDBOutputConverter(CachedOutputConverter):
+    """DuckDB-specific output conversion with native UUID support.
+
+    Extends CachedOutputConverter with DuckDB-specific functionality
+    including native UUID handling and standardized datetime formatting.
+    """
+
+    __slots__ = ("_enable_uuid_conversion",)
+
+    def __init__(self, cache_size: int = 5000, enable_uuid_conversion: bool = True) -> None:
+        """Initialize converter with DuckDB-specific options.
+
+        Args:
+            cache_size: Maximum number of string values to cache (default: 5000)
+            enable_uuid_conversion: Enable automatic UUID string conversion (default: True)
+        """
+        super().__init__(special_chars=DUCKDB_SPECIAL_CHARS, cache_size=cache_size)
+        self._enable_uuid_conversion = enable_uuid_conversion
+
+    def _convert_detected(self, value: str, detected_type: str) -> Any:
+        """Convert value with DuckDB-specific UUID handling.
+
+        Args:
+            value: String value to convert.
+            detected_type: Detected type name.
+
+        Returns:
+            Converted value, respecting UUID conversion setting.
+        """
+        if detected_type == "uuid" and not self._enable_uuid_conversion:
+            return value
+        try:
+            return self.convert_value(value, detected_type)
+        except Exception:
+            return value
+
+    def handle_uuid(self, value: Any) -> Any:
+        """Handle UUID conversion for DuckDB.
+
+        Args:
+            value: Value that might be a UUID.
+
+        Returns:
+            UUID object if value is UUID-like and conversion enabled, original value otherwise.
+        """
+        if isinstance(value, UUID):
+            return value
+
+        if isinstance(value, str) and self._enable_uuid_conversion:
+            detected_type = self.detect_type(value)
+            if detected_type == "uuid":
+                return convert_uuid(value)
+
+        return value
+
+    def format_datetime(self, dt: datetime) -> str:
+        """Standardized datetime formatting for DuckDB.
+
+        Args:
+            dt: datetime object to format.
+
+        Returns:
+            RFC 3339 formatted datetime string.
+        """
+        return format_datetime_rfc3339(dt)
+
+    def convert_duckdb_value(self, value: Any) -> Any:
+        """Convert value with DuckDB-specific handling.
+
+        Args:
+            value: Value to convert.
+
+        Returns:
+            Converted value appropriate for DuckDB.
+        """
+        if isinstance(value, (str, UUID)):
+            uuid_value = self.handle_uuid(value)
+            if isinstance(uuid_value, UUID):
+                return uuid_value
+
+        if isinstance(value, str):
+            return self.convert(value)
+
+        if isinstance(value, datetime):
+            return self.format_datetime(value)
+
+        return value
+
+    def prepare_duckdb_parameter(self, value: Any) -> Any:
+        """Prepare parameter for DuckDB execution.
+
+        Args:
+            value: Parameter value to prepare.
+
+        Returns:
+            Value ready for DuckDB parameter binding.
+        """
+        converted = self.convert_duckdb_value(value)
+        if isinstance(converted, UUID):
+            return converted
+        return converted

sqlspec/adapters/mock/__init__.py

@@ -0,0 +1,72 @@
+"""Mock adapter for SQLSpec.
+
+This adapter provides mock database drivers that use SQLite :memory: as the
+execution backend while accepting SQL written in other dialects (Postgres,
+MySQL, Oracle, etc.). SQL is transpiled to SQLite syntax before execution
+using sqlglot.
+
+Key Features:
+    - Write SQL in your target dialect (Postgres, MySQL, Oracle, SQLite)
+    - SQL is transpiled to SQLite before execution
+    - Fast execution using SQLite :memory: database
+    - Same API as real database adapters
+    - Both sync and async drivers available
+    - Initial SQL support for test fixtures
+
+Example:
+    >>> from sqlspec.adapters.mock import MockSyncConfig
+    >>>
+    >>> # Create config with Postgres dialect
+    >>> config = MockSyncConfig(target_dialect="postgres")
+    >>>
+    >>> # Use Postgres syntax - it will be transpiled to SQLite
+    >>> with config.provide_session() as session:
+    ...     session.execute(\"\"\"
+    ...         CREATE TABLE users (
+    ...             id SERIAL PRIMARY KEY,
+    ...             name VARCHAR(100)
+    ...         )
+    ...     \"\"\")
+    ...     session.execute("INSERT INTO users (name) VALUES ($1)", "Alice")
+    ...     user = session.select_one("SELECT * FROM users WHERE name = $1", "Alice")
+    ...     print(user["name"])
+    Alice
+
+With Test Fixtures:
+    >>> config = MockSyncConfig(
+    ...     target_dialect="postgres",
+    ...     initial_sql=[
+    ...         "CREATE TABLE users (id INT, name TEXT, role TEXT)",
+    ...         "INSERT INTO users VALUES (1, 'Alice', 'admin')",
+    ...         "INSERT INTO users VALUES (2, 'Bob', 'user')",
+    ...     ],
+    ... )
+    >>>
+    >>> with config.provide_session() as session:
+    ...     admins = session.select(
+    ...         "SELECT * FROM users WHERE role = $1", "admin"
+    ...     )
+    ...     print(len(admins))
+    1
+"""
+
+from sqlspec.adapters.mock._typing import MockAsyncSessionContext, MockConnection, MockSyncSessionContext
+from sqlspec.adapters.mock.config import MockAsyncConfig, MockConnectionParams, MockDriverFeatures, MockSyncConfig
+from sqlspec.adapters.mock.data_dictionary import MockAsyncDataDictionary, MockDataDictionary
+from sqlspec.adapters.mock.driver import MockAsyncDriver, MockCursor, MockExceptionHandler, MockSyncDriver
+
+__all__ = (
+    "MockAsyncConfig",
+    "MockAsyncDataDictionary",
+    "MockAsyncDriver",
+    "MockAsyncSessionContext",
+    "MockConnection",
+    "MockConnectionParams",
+    "MockCursor",
+    "MockDataDictionary",
+    "MockDriverFeatures",
+    "MockExceptionHandler",
+    "MockSyncConfig",
+    "MockSyncDriver",
+    "MockSyncSessionContext",
+)

sqlspec/adapters/mock/_typing.py

@@ -0,0 +1,147 @@
+"""Mock adapter type definitions.
+
+This module contains type aliases and classes that are excluded from mypyc
+compilation to avoid ABI boundary issues.
+"""
+
+import sqlite3
+from typing import TYPE_CHECKING, Any
+
+_MockConnection = sqlite3.Connection
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+    from typing import TypeAlias
+
+    from sqlspec.adapters.mock.driver import MockAsyncDriver, MockSyncDriver
+    from sqlspec.core import StatementConfig
+
+    MockConnection: TypeAlias = _MockConnection
+
+if not TYPE_CHECKING:
+    MockConnection = _MockConnection
+
+
+class MockSyncSessionContext:
+    """Sync context manager for Mock sessions.
+
+    This class is intentionally excluded from mypyc compilation to avoid ABI
+    boundary issues. It receives callables from uncompiled config classes and
+    instantiates compiled Driver objects, acting as a bridge between compiled
+    and uncompiled code.
+
+    Uses callable-based connection management to decouple from config implementation.
+    """
+
+    __slots__ = (
+        "_acquire_connection",
+        "_connection",
+        "_driver",
+        "_driver_features",
+        "_prepare_driver",
+        "_release_connection",
+        "_statement_config",
+        "_target_dialect",
+    )
+
+    def __init__(
+        self,
+        acquire_connection: "Callable[[], MockConnection]",
+        release_connection: "Callable[[MockConnection], None]",
+        statement_config: "StatementConfig",
+        driver_features: "dict[str, Any]",
+        prepare_driver: "Callable[[MockSyncDriver], MockSyncDriver]",
+        target_dialect: str = "sqlite",
+    ) -> None:
+        self._acquire_connection = acquire_connection
+        self._release_connection = release_connection
+        self._statement_config = statement_config
+        self._driver_features = driver_features
+        self._prepare_driver = prepare_driver
+        self._target_dialect = target_dialect
+        self._connection: MockConnection | None = None
+        self._driver: MockSyncDriver | None = None
+
+    def __enter__(self) -> "MockSyncDriver":
+        from sqlspec.adapters.mock.driver import MockSyncDriver
+
+        self._connection = self._acquire_connection()
+        self._driver = MockSyncDriver(
+            connection=self._connection,
+            statement_config=self._statement_config,
+            driver_features=self._driver_features,
+            target_dialect=self._target_dialect,
+        )
+        return self._prepare_driver(self._driver)
+
+    def __exit__(
+        self, exc_type: "type[BaseException] | None", exc_val: "BaseException | None", exc_tb: Any
+    ) -> "bool | None":
+        if self._connection is not None:
+            self._release_connection(self._connection)
+            self._connection = None
+        return None
+
+
+class MockAsyncSessionContext:
+    """Async context manager for Mock sessions.
+
+    This class is intentionally excluded from mypyc compilation to avoid ABI
+    boundary issues. It receives callables from uncompiled config classes and
+    instantiates compiled Driver objects, acting as a bridge between compiled
+    and uncompiled code.
+
+    Uses callable-based connection management to decouple from config implementation.
+    """
+
+    __slots__ = (
+        "_acquire_connection",
+        "_connection",
+        "_driver",
+        "_driver_features",
+        "_prepare_driver",
+        "_release_connection",
+        "_statement_config",
+        "_target_dialect",
+    )
+
+    def __init__(
+        self,
+        acquire_connection: "Callable[[], Awaitable[MockConnection]]",
+        release_connection: "Callable[[MockConnection], Awaitable[None]]",
+        statement_config: "StatementConfig",
+        driver_features: "dict[str, Any]",
+        prepare_driver: "Callable[[MockAsyncDriver], MockAsyncDriver]",
+        target_dialect: str = "sqlite",
+    ) -> None:
+        self._acquire_connection = acquire_connection
+        self._release_connection = release_connection
+        self._statement_config = statement_config
+        self._driver_features = driver_features
+        self._prepare_driver = prepare_driver
+        self._target_dialect = target_dialect
+        self._connection: MockConnection | None = None
+        self._driver: MockAsyncDriver | None = None
+
+    async def __aenter__(self) -> "MockAsyncDriver":
+        from sqlspec.adapters.mock.driver import MockAsyncDriver
+
+        self._connection = await self._acquire_connection()
+        self._driver = MockAsyncDriver(
+            connection=self._connection,
+            statement_config=self._statement_config,
+            driver_features=self._driver_features,
+            target_dialect=self._target_dialect,
+        )
+        return self._prepare_driver(self._driver)
+
+    async def __aexit__(
+        self, exc_type: "type[BaseException] | None", exc_val: "BaseException | None", exc_tb: Any
+    ) -> "bool | None":
+        if self._connection is not None:
+            await self._release_connection(self._connection)
+            self._connection = None
+        return None
+
+
+__all__ = ("MockAsyncSessionContext", "MockConnection", "MockSyncSessionContext")