sqlspec 0.16.1__cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl

sqlspec/adapters/aiosqlite/config.py

@@ -0,0 +1,253 @@
+"""Aiosqlite database configuration with optimized connection management."""
+
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, Any, ClassVar, Final, Optional, TypedDict
+
+import aiosqlite
+from typing_extensions import NotRequired
+
+from sqlspec.adapters.aiosqlite.driver import AiosqliteCursor, AiosqliteDriver, aiosqlite_statement_config
+from sqlspec.config import AsyncDatabaseConfig
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
+    from sqlspec.adapters.aiosqlite._types import AiosqliteConnection
+    from sqlspec.core.statement import StatementConfig
+
+__all__ = ("AiosqliteConfig", "AiosqliteConnectionParams", "AiosqliteConnectionPool")
+
+logger = logging.getLogger(__name__)
+
+# Core PRAGMAs for SQLite performance optimization
+WAL_PRAGMA_SQL: Final[str] = "PRAGMA journal_mode = WAL"
+FOREIGN_KEYS_SQL: Final[str] = "PRAGMA foreign_keys = ON"
+SYNC_NORMAL_SQL: Final[str] = "PRAGMA synchronous = NORMAL"
+BUSY_TIMEOUT_SQL: Final[str] = "PRAGMA busy_timeout = 5000"  # 5 seconds
+
+
+class AiosqliteConnectionPool:
+    """Connection pool for Aiosqlite using a single shared connection approach.
+
+    Uses a single shared connection per database file since aiosqlite internally
+    handles queuing and serialization of operations.
+    """
+
+    __slots__ = ("_closed", "_connection", "_connection_parameters", "_lock")
+
+    def __init__(self, connection_parameters: "dict[str, Any]") -> None:
+        """Initialize connection manager.
+
+        Args:
+            connection_parameters: SQLite connection parameters
+        """
+        self._connection: Optional[AiosqliteConnection] = None
+        self._connection_parameters = connection_parameters
+        self._lock = asyncio.Lock()
+        self._closed = False
+
+    async def _ensure_connection(self) -> "AiosqliteConnection":
+        """Ensure we have a valid connection, creating one if needed."""
+        async with self._lock:
+            if self._connection is None or self._closed:
+                self._connection = await aiosqlite.connect(**self._connection_parameters)
+
+                await self._connection.execute(WAL_PRAGMA_SQL)
+                await self._connection.execute(FOREIGN_KEYS_SQL)
+                await self._connection.execute(SYNC_NORMAL_SQL)
+                await self._connection.execute(BUSY_TIMEOUT_SQL)
+                await self._connection.commit()
+
+                self._closed = False
+                logger.debug("Created new aiosqlite connection")
+
+            return self._connection
+
+    @asynccontextmanager
+    async def get_connection(self) -> "AsyncGenerator[AiosqliteConnection, None]":
+        """Get the shared connection.
+
+        Yields:
+            The shared Aiosqlite connection instance.
+        """
+        connection = await self._ensure_connection()
+        yield connection
+
+    async def close(self) -> None:
+        """Close the shared connection."""
+        async with self._lock:
+            if self._connection is not None and not self._closed:
+                await self._connection.close()
+                self._connection = None
+                self._closed = True
+                logger.debug("Closed aiosqlite connection")
+
+    def size(self) -> int:
+        """Get connection count."""
+        return 0 if self._closed or self._connection is None else 1
+
+    def checked_out(self) -> int:
+        """Get number of checked out connections."""
+        return 0
+
+    async def acquire(self) -> "AiosqliteConnection":
+        """Get the shared connection directly.
+
+        Returns:
+            The shared connection instance.
+        """
+        return await self._ensure_connection()
+
+    async def release(self, connection: "AiosqliteConnection") -> None:
+        """No-op release for compatibility.
+
+        Args:
+            connection: Connection to release (ignored)
+        """
+        _ = connection
+
+
+class AiosqliteConnectionParams(TypedDict, total=False):
+    """aiosqlite connection parameters."""
+
+    database: NotRequired[str]
+    timeout: NotRequired[float]
+    detect_types: NotRequired[int]
+    isolation_level: NotRequired[Optional[str]]
+    check_same_thread: NotRequired[bool]
+    cached_statements: NotRequired[int]
+    uri: NotRequired[bool]
+
+
+class AiosqliteConfig(AsyncDatabaseConfig):
+    """Database configuration for AioSQLite engine."""
+
+    driver_type: ClassVar[type[AiosqliteDriver]] = AiosqliteDriver
+    cursor_type: ClassVar[type[AiosqliteCursor]] = AiosqliteCursor
+
+    def __init__(
+        self,
+        *,
+        pool_instance: "Optional[AiosqliteConnectionPool]" = None,
+        pool_config: "Optional[dict[str, Any]]" = None,
+        migration_config: "Optional[dict[str, Any]]" = None,
+        statement_config: "Optional[StatementConfig]" = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize AioSQLite configuration.
+
+        Args:
+            pool_instance: Optional pre-configured connection pool instance.
+            pool_config: Optional pool configuration dict (AiosqliteConnectionParams).
+            migration_config: Optional migration configuration.
+            statement_config: Optional statement configuration.
+            **kwargs: Additional connection parameters.
+        """
+        connection_params = {}
+        if pool_config:
+            connection_params.update(pool_config)
+        connection_params.update(kwargs)
+
+        super().__init__(
+            pool_config=connection_params,
+            pool_instance=pool_instance,
+            migration_config=migration_config or {},
+            statement_config=statement_config or aiosqlite_statement_config,
+        )
+
+        self._connection_parameters = self._parse_connection_parameters(connection_params)
+
+        if pool_instance is None:
+            self.pool_instance: AiosqliteConnectionPool = AiosqliteConnectionPool(self._connection_parameters)
+
+    def _parse_connection_parameters(self, params: "dict[str, Any]") -> "dict[str, Any]":
+        """Parse connection parameters for AioSQLite.
+
+        Args:
+            params: Connection parameters dict.
+
+        Returns:
+            Processed connection parameters dict.
+        """
+        result = params.copy()
+
+        if "database" not in result:
+            # Default to in-memory database
+            result["database"] = ":memory:"
+
+        # Convert regular :memory: to shared memory for multi-connection access
+        if result.get("database") == ":memory:":
+            result["database"] = "file::memory:?cache=shared"
+            result["uri"] = True
+
+        for pool_param in ["pool_min_size", "pool_max_size", "pool_timeout", "pool_recycle_seconds"]:
+            result.pop(pool_param, None)
+
+        return result
+
+    @asynccontextmanager
+    async def provide_connection(self) -> "AsyncGenerator[AiosqliteConnection, None]":
+        """Provide a database connection.
+
+        Yields:
+            AiosqliteConnection: Database connection instance.
+        """
+        async with self.pool_instance.get_connection() as connection:
+            yield connection
+
+    @asynccontextmanager
+    async def provide_session(
+        self, *args: Any, statement_config: "Optional[StatementConfig]" = None, **kwargs: Any
+    ) -> "AsyncGenerator[AiosqliteDriver, None]":
+        """Provide an async database session.
+
+        Args:
+            *args: Additional positional arguments.
+            statement_config: Optional statement configuration override.
+            **kwargs: Additional keyword arguments.
+
+        Yields:
+            AiosqliteDriver: Database session instance.
+        """
+        _ = args, kwargs
+        effective_statement_config = statement_config or self.statement_config
+        async with self.pool_instance.get_connection() as connection:
+            session = self.driver_type(connection, statement_config=effective_statement_config)
+            try:
+                yield session
+            finally:
+                pass
+
+    async def close(self) -> None:
+        """Close the connection manager."""
+        if self.pool_instance:
+            await self.pool_instance.close()
+
+    def _get_connection_config_dict(self) -> "dict[str, Any]":
+        """Get connection configuration dictionary.
+
+        Returns:
+            Connection parameters for creating connections.
+        """
+        return self._connection_parameters.copy()
+
+    async def _create_pool(self) -> "AiosqliteConnectionPool":
+        """Create the connection manager instance.
+
+        Returns:
+            AiosqliteConnectionPool: The connection manager instance.
+        """
+        if self.pool_instance is None:
+            self.pool_instance = AiosqliteConnectionPool(self._connection_parameters)
+        return self.pool_instance
+
+    async def _close_pool(self) -> None:
+        """Close the connection manager."""
+        if self.pool_instance:
+            await self.pool_instance.close()
+
+    async def close_pool(self) -> None:
+        """Close the connection pool (delegates to _close_pool)."""
+        await self._close_pool()

sqlspec/adapters/aiosqlite/driver.py

@@ -0,0 +1,248 @@
+"""AIOSQLite driver implementation for async SQLite operations.
+
+Provides async SQLite database connectivity with:
+- Async parameter processing with type coercion
+- Thread-safe caching system
+- Context management for resource handling
+- SQLite-specific optimizations
+"""
+
+import contextlib
+import datetime
+from decimal import Decimal
+from typing import TYPE_CHECKING, Any, Optional
+
+import aiosqlite
+
+from sqlspec.core.cache import get_cache_config
+from sqlspec.core.parameters import ParameterStyle, ParameterStyleConfig
+from sqlspec.core.statement import StatementConfig
+from sqlspec.driver import AsyncDriverAdapterBase
+from sqlspec.exceptions import SQLParsingError, SQLSpecError
+from sqlspec.utils.serializers import to_json
+
+if TYPE_CHECKING:
+    from contextlib import AbstractAsyncContextManager
+
+    from sqlspec.adapters.aiosqlite._types import AiosqliteConnection
+    from sqlspec.core.result import SQLResult
+    from sqlspec.core.statement import SQL
+    from sqlspec.driver import ExecutionResult
+
+__all__ = ("AiosqliteCursor", "AiosqliteDriver", "AiosqliteExceptionHandler", "aiosqlite_statement_config")
+
+
+aiosqlite_statement_config = StatementConfig(
+    dialect="sqlite",
+    parameter_config=ParameterStyleConfig(
+        default_parameter_style=ParameterStyle.QMARK,
+        supported_parameter_styles={ParameterStyle.QMARK},
+        default_execution_parameter_style=ParameterStyle.QMARK,
+        supported_execution_parameter_styles={ParameterStyle.QMARK},
+        type_coercion_map={
+            bool: int,
+            datetime.datetime: lambda v: v.isoformat(),
+            datetime.date: lambda v: v.isoformat(),
+            Decimal: str,
+            dict: to_json,
+            list: to_json,
+            tuple: lambda v: to_json(list(v)),
+        },
+        has_native_list_expansion=False,
+        needs_static_script_compilation=False,
+        preserve_parameter_format=True,
+    ),
+    enable_parsing=True,
+    enable_validation=True,
+    enable_caching=True,
+    enable_parameter_type_wrapping=True,
+)
+
+
+class AiosqliteCursor:
+    """Async context manager for AIOSQLite cursor management."""
+
+    __slots__ = ("connection", "cursor")
+
+    def __init__(self, connection: "AiosqliteConnection") -> None:
+        self.connection = connection
+        self.cursor: Optional[aiosqlite.Cursor] = None
+
+    async def __aenter__(self) -> "aiosqlite.Cursor":
+        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)
+        if self.cursor is not None:
+            with contextlib.suppress(Exception):
+                await self.cursor.close()
+
+
+class AiosqliteExceptionHandler:
+    """Custom async context manager for handling AIOSQLite database exceptions."""
+
+    __slots__ = ()
+
+    async def __aenter__(self) -> None:
+        return None
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        if exc_type is None:
+            return
+        if issubclass(exc_type, aiosqlite.IntegrityError):
+            e = exc_val
+            msg = f"AIOSQLite integrity constraint violation: {e}"
+            raise SQLSpecError(msg) from e
+        if issubclass(exc_type, aiosqlite.OperationalError):
+            e = exc_val
+            error_msg = str(e).lower()
+            if "locked" in error_msg:
+                msg = f"AIOSQLite database locked: {e}. Consider enabling WAL mode or reducing concurrency."
+                raise SQLSpecError(msg) from e
+            if "syntax" in error_msg or "malformed" in error_msg:
+                msg = f"AIOSQLite SQL syntax error: {e}"
+                raise SQLParsingError(msg) from e
+            msg = f"AIOSQLite operational error: {e}"
+            raise SQLSpecError(msg) from e
+        if issubclass(exc_type, aiosqlite.DatabaseError):
+            e = exc_val
+            msg = f"AIOSQLite database error: {e}"
+            raise SQLSpecError(msg) from e
+        if issubclass(exc_type, aiosqlite.Error):
+            e = exc_val
+            msg = f"AIOSQLite error: {e}"
+            raise SQLSpecError(msg) from e
+        if issubclass(exc_type, Exception):
+            e = exc_val
+            error_msg = str(e).lower()
+            if "parse" in error_msg or "syntax" in error_msg:
+                msg = f"SQL parsing failed: {e}"
+                raise SQLParsingError(msg) from e
+            msg = f"Unexpected async database operation error: {e}"
+            raise SQLSpecError(msg) from e
+
+
+class AiosqliteDriver(AsyncDriverAdapterBase):
+    """AIOSQLite driver for async SQLite database operations.
+
+    Provides async SQLite connectivity with:
+    - Statement processing and parameter handling
+    - Cursor management and resource cleanup
+    - Exception handling for SQLite operations
+    """
+
+    __slots__ = ()
+    dialect = "sqlite"
+
+    def __init__(
+        self,
+        connection: "AiosqliteConnection",
+        statement_config: "Optional[StatementConfig]" = None,
+        driver_features: "Optional[dict[str, Any]]" = None,
+    ) -> None:
+        if statement_config is None:
+            cache_config = get_cache_config()
+            enhanced_config = aiosqlite_statement_config.replace(
+                enable_caching=cache_config.compiled_cache_enabled,
+                enable_parsing=True,
+                enable_validation=True,
+                dialect="sqlite",
+            )
+            statement_config = enhanced_config
+
+        super().__init__(connection=connection, statement_config=statement_config, driver_features=driver_features)
+
+    def with_cursor(self, connection: "AiosqliteConnection") -> "AiosqliteCursor":
+        """Create async context manager for AIOSQLite cursor."""
+        return AiosqliteCursor(connection)
+
+    def handle_database_exceptions(self) -> "AbstractAsyncContextManager[None]":
+        """Handle AIOSQLite-specific exceptions."""
+        return AiosqliteExceptionHandler()
+
+    async def _try_special_handling(self, cursor: "aiosqlite.Cursor", statement: "SQL") -> "Optional[SQLResult]":
+        """Hook for AIOSQLite-specific special operations.
+
+        Args:
+            cursor: AIOSQLite cursor object
+            statement: SQL statement to analyze
+
+        Returns:
+            None - always proceeds with standard execution for AIOSQLite
+        """
+        _ = (cursor, statement)
+        return None
+
+    async def _execute_script(self, cursor: "aiosqlite.Cursor", statement: "SQL") -> "ExecutionResult":
+        """Execute SQL script using statement splitting and parameter handling."""
+        sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
+        statements = self.split_script_statements(sql, statement.statement_config, strip_trailing_semicolon=True)
+
+        successful_count = 0
+        last_cursor = cursor
+
+        for stmt in statements:
+            await cursor.execute(stmt, prepared_parameters or ())
+            successful_count += 1
+
+        return self.create_execution_result(
+            last_cursor, statement_count=len(statements), successful_statements=successful_count, is_script_result=True
+        )
+
+    async def _execute_many(self, cursor: "aiosqlite.Cursor", statement: "SQL") -> "ExecutionResult":
+        """Execute SQL with multiple parameter sets using async batch processing."""
+        sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
+
+        if not prepared_parameters:
+            msg = "execute_many requires parameters"
+            raise ValueError(msg)
+
+        await cursor.executemany(sql, prepared_parameters)
+
+        affected_rows = cursor.rowcount if cursor.rowcount and cursor.rowcount > 0 else 0
+
+        return self.create_execution_result(cursor, rowcount_override=affected_rows, is_many_result=True)
+
+    async def _execute_statement(self, cursor: "aiosqlite.Cursor", statement: "SQL") -> "ExecutionResult":
+        """Execute single SQL statement with async data handling."""
+        sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
+        await cursor.execute(sql, prepared_parameters or ())
+
+        if statement.returns_rows():
+            fetched_data = await cursor.fetchall()
+            column_names = [col[0] for col in cursor.description or []]
+
+            data = [dict(zip(column_names, row)) for row in fetched_data]
+
+            return self.create_execution_result(
+                cursor, selected_data=data, column_names=column_names, data_row_count=len(data), is_select_result=True
+            )
+
+        affected_rows = cursor.rowcount if cursor.rowcount and cursor.rowcount > 0 else 0
+        return self.create_execution_result(cursor, rowcount_override=affected_rows)
+
+    async def begin(self) -> None:
+        """Begin a database transaction."""
+        try:
+            if not self.connection.in_transaction:
+                await self.connection.execute("BEGIN")
+        except aiosqlite.Error as e:
+            msg = f"Failed to begin transaction: {e}"
+            raise SQLSpecError(msg) from e
+
+    async def rollback(self) -> None:
+        """Rollback the current transaction."""
+        try:
+            await self.connection.rollback()
+        except aiosqlite.Error as e:
+            msg = f"Failed to rollback transaction: {e}"
+            raise SQLSpecError(msg) from e
+
+    async def commit(self) -> None:
+        """Commit the current transaction."""
+        try:
+            await self.connection.commit()
+        except aiosqlite.Error as e:
+            msg = f"Failed to commit transaction: {e}"
+            raise SQLSpecError(msg) from e

sqlspec/adapters/asyncmy/__init__.py

@@ -0,0 +1,19 @@
+from sqlspec.adapters.asyncmy._types import AsyncmyConnection
+from sqlspec.adapters.asyncmy.config import AsyncmyConfig, AsyncmyConnectionParams, AsyncmyPoolParams
+from sqlspec.adapters.asyncmy.driver import (
+    AsyncmyCursor,
+    AsyncmyDriver,
+    AsyncmyExceptionHandler,
+    asyncmy_statement_config,
+)
+
+__all__ = (
+    "AsyncmyConfig",
+    "AsyncmyConnection",
+    "AsyncmyConnectionParams",
+    "AsyncmyCursor",
+    "AsyncmyDriver",
+    "AsyncmyExceptionHandler",
+    "AsyncmyPoolParams",
+    "asyncmy_statement_config",
+)

sqlspec/adapters/asyncmy/_types.py

@@ -0,0 +1,12 @@
+from typing import TYPE_CHECKING
+
+from asyncmy import Connection
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    AsyncmyConnection: TypeAlias = Connection
+else:
+    AsyncmyConnection = Connection
+
+__all__ = ("AsyncmyConnection",)