sqlspec 0.17.1__py3-none-any.whl → 0.19.0__py3-none-any.whl

sqlspec/adapters/adbc/config.py

@@ -1,4 +1,4 @@
-"""ADBC database configuration using TypedDict for better maintainability."""
+"""ADBC database configuration."""
 
 import logging
 from contextlib import contextmanager
@@ -60,16 +60,11 @@ __all__ = ("AdbcConfig", "AdbcConnectionParams")
 class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
     """ADBC configuration for Arrow Database Connectivity.
 
-    ADBC (Arrow Database Connectivity) provides a unified interface for connecting
-    to multiple database systems with Arrow-native data transfer.
+    ADBC provides an interface for connecting to multiple database systems
+    with Arrow-native data transfer.
 
-    This configuration supports:
-    - Universal driver detection and loading
-    - Arrow data streaming
-    - Bulk ingestion operations
-    - Multiple database backends (PostgreSQL, SQLite, DuckDB, BigQuery, Snowflake, etc.)
-    - Driver path resolution
-    - Cloud database integrations
+    Supports multiple database backends including PostgreSQL, SQLite, DuckDB,
+    BigQuery, and Snowflake with automatic driver detection and loading.
     """
 
     driver_type: ClassVar[type[AdbcDriver]] = AdbcDriver
@@ -79,15 +74,17 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
         self,
         *,
         connection_config: Optional[Union[AdbcConnectionParams, dict[str, Any]]] = None,
-        statement_config: Optional[StatementConfig] = None,
         migration_config: Optional[dict[str, Any]] = None,
+        statement_config: Optional[StatementConfig] = None,
+        driver_features: Optional[dict[str, Any]] = None,
     ) -> None:
-        """Initialize ADBC configuration.
+        """Initialize configuration.
 
         Args:
             connection_config: Connection configuration parameters
-            statement_config: Default SQL statement configuration
             migration_config: Migration configuration
+            statement_config: Default SQL statement configuration
+            driver_features: Driver feature configuration
         """
         if connection_config is None:
             connection_config = {}
@@ -106,11 +103,11 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
             connection_config=self.connection_config,
             migration_config=migration_config,
             statement_config=statement_config,
-            driver_features={},
+            driver_features=driver_features or {},
         )
 
     def _resolve_driver_name(self) -> str:
-        """Resolve and normalize the ADBC driver name.
+        """Resolve and normalize the driver name.
 
         Returns:
             The normalized driver connect function path.
@@ -164,7 +161,7 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
         return "adbc_driver_sqlite.dbapi.connect"
 
     def _get_connect_func(self) -> Callable[..., AdbcConnection]:
-        """Get the ADBC driver connect function.
+        """Get the driver connect function.
 
         Returns:
             The driver connect function.
@@ -182,7 +179,7 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
                 connect_func = import_string(driver_path_with_suffix)
             except ImportError as e2:
                 msg = (
-                    f"Failed to import ADBC connect function from '{driver_path}' or "
+                    f"Failed to import connect function from '{driver_path}' or "
                     f"'{driver_path_with_suffix}'. Is the driver installed? "
                     f"Original errors: {e} / {e2}"
                 )
@@ -195,10 +192,10 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
         return connect_func  # type: ignore[no-any-return]
 
     def _get_dialect(self) -> "DialectType":
-        """Get the SQL dialect type based on the ADBC driver.
+        """Get the SQL dialect type based on the driver.
 
         Returns:
-            The SQL dialect type for the ADBC driver.
+            The SQL dialect type for the driver.
         """
         try:
             driver_path = self._resolve_driver_name()
@@ -239,14 +236,14 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
                 return (("qmark", "numeric"), "qmark")
 
         except Exception:
-            logger.debug("Error resolving parameter styles for ADBC driver, using defaults")
+            logger.debug("Error resolving parameter styles, using defaults")
         return (("qmark",), "qmark")
 
     def create_connection(self) -> AdbcConnection:
-        """Create and return a new ADBC connection using the specified driver.
+        """Create and return a new connection using the specified driver.
 
         Returns:
-            A new ADBC connection instance.
+            A new connection instance.
 
         Raises:
             ImproperConfigurationError: If the connection could not be established.
@@ -258,20 +255,20 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
             connection = connect_func(**connection_config_dict)
         except Exception as e:
             driver_name = self.connection_config.get("driver_name", "Unknown")
-            msg = f"Could not configure ADBC connection using driver '{driver_name}'. Error: {e}"
+            msg = f"Could not configure connection using driver '{driver_name}'. Error: {e}"
             raise ImproperConfigurationError(msg) from e
         return connection
 
     @contextmanager
     def provide_connection(self, *args: Any, **kwargs: Any) -> "Generator[AdbcConnection, None, None]":
-        """Provide an ADBC connection context manager.
+        """Provide a connection context manager.
 
         Args:
             *args: Additional arguments.
             **kwargs: Additional keyword arguments.
 
         Yields:
-            An ADBC connection instance.
+            A connection instance.
         """
         connection = self.create_connection()
         try:
@@ -282,7 +279,7 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
     def provide_session(
         self, *args: Any, statement_config: "Optional[StatementConfig]" = None, **kwargs: Any
     ) -> "AbstractContextManager[AdbcDriver]":
-        """Provide an ADBC driver session context manager.
+        """Provide a driver session context manager.
 
         Args:
             *args: Additional arguments.
@@ -347,10 +344,7 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
         return config
 
     def get_signature_namespace(self) -> "dict[str, type[Any]]":
-        """Get the signature namespace for ADBC types.
-
-        This provides all ADBC-specific types that Litestar needs to recognize
-        to avoid serialization attempts.
+        """Get the signature namespace for types.
 
         Returns:
             Dictionary mapping type names to types.

sqlspec/adapters/adbc/driver.py

@@ -1,10 +1,8 @@
 """ADBC driver implementation for Arrow Database Connectivity.
 
-This module provides ADBC driver integration with support for:
-- Multi-dialect database connections through ADBC
-- Arrow-native data handling with type coercion
-- Parameter style conversion for different database backends
-- Transaction management with proper error handling
+Provides ADBC driver integration with multi-dialect database connections,
+Arrow-native data handling with type coercion, parameter style conversion
+for different database backends, and transaction management.
 """
 
 import contextlib
@@ -48,7 +46,7 @@ DIALECT_PARAMETER_STYLES = {
     "postgres": (ParameterStyle.NUMERIC, [ParameterStyle.NUMERIC]),
     "postgresql": (ParameterStyle.NUMERIC, [ParameterStyle.NUMERIC]),
     "bigquery": (ParameterStyle.NAMED_AT, [ParameterStyle.NAMED_AT]),
-    "sqlite": (ParameterStyle.QMARK, [ParameterStyle.QMARK, ParameterStyle.NAMED_COLON]),
+    "sqlite": (ParameterStyle.QMARK, [ParameterStyle.QMARK]),
     "duckdb": (ParameterStyle.QMARK, [ParameterStyle.QMARK, ParameterStyle.NUMERIC, ParameterStyle.NAMED_DOLLAR]),
     "mysql": (ParameterStyle.POSITIONAL_PYFORMAT, [ParameterStyle.POSITIONAL_PYFORMAT, ParameterStyle.NAMED_PYFORMAT]),
     "snowflake": (ParameterStyle.QMARK, [ParameterStyle.QMARK, ParameterStyle.NUMERIC]),
@@ -56,17 +54,11 @@ DIALECT_PARAMETER_STYLES = {
 
 
 def _adbc_ast_transformer(expression: Any, parameters: Any) -> tuple[Any, Any]:
-    """ADBC-specific AST transformer for NULL parameter handling.
+    """AST transformer for NULL parameter handling.
 
-    For PostgreSQL, this transformer replaces NULL parameter placeholders with NULL literals
+    For PostgreSQL, replaces NULL parameter placeholders with NULL literals
     in the AST to prevent Arrow from inferring 'na' types which cause binding errors.
 
-    The transformer:
-    1. Detects None parameters in the parameter list
-    2. Replaces corresponding placeholders in the AST with NULL literals
-    3. Removes the None parameters from the list
-    4. Renumbers remaining placeholders to maintain correct mapping
-
     Args:
         expression: SQLGlot AST expression
         parameters: Parameter values that may contain None
@@ -77,7 +69,6 @@ def _adbc_ast_transformer(expression: Any, parameters: Any) -> tuple[Any, Any]:
     if not parameters:
         return expression, parameters
 
-    # Detect NULL parameter positions
     null_positions = set()
     if isinstance(parameters, (list, tuple)):
         for i, param in enumerate(parameters):
@@ -96,47 +87,42 @@ def _adbc_ast_transformer(expression: Any, parameters: Any) -> tuple[Any, Any]:
     if not null_positions:
         return expression, parameters
 
-    # Track position for QMARK-style placeholders
     qmark_position = [0]
 
     def transform_node(node: Any) -> Any:
-        """Transform parameter nodes to NULL literals and renumber remaining ones."""
-        # Handle QMARK-style placeholders (?, ?, ?)
         if isinstance(node, exp.Placeholder) and (not hasattr(node, "this") or node.this is None):
             current_pos = qmark_position[0]
             qmark_position[0] += 1
 
             if current_pos in null_positions:
                 return exp.Null()
-            # Don't renumber QMARK placeholders - they stay as ?
+
             return node
 
-        # Handle PostgreSQL-style placeholders ($1, $2, etc.)
         if isinstance(node, exp.Placeholder) and hasattr(node, "this") and node.this is not None:
             try:
                 param_str = str(node.this).lstrip("$")
                 param_num = int(param_str)
-                param_index = param_num - 1  # Convert to 0-based
+                param_index = param_num - 1
 
                 if param_index in null_positions:
                     return exp.Null()
-                # Renumber placeholder to account for removed NULLs
+
                 nulls_before = sum(1 for idx in null_positions if idx < param_index)
                 new_param_num = param_num - nulls_before
                 return exp.Placeholder(this=f"${new_param_num}")
             except (ValueError, AttributeError):
                 pass
 
-        # Handle generic parameter nodes
         if isinstance(node, exp.Parameter) and hasattr(node, "this"):
             try:
                 param_str = str(node.this)
                 param_num = int(param_str)
-                param_index = param_num - 1  # Convert to 0-based
+                param_index = param_num - 1
 
                 if param_index in null_positions:
                     return exp.Null()
-                # Renumber parameter to account for removed NULLs
+
                 nulls_before = sum(1 for idx in null_positions if idx < param_index)
                 new_param_num = param_num - nulls_before
                 return exp.Parameter(this=str(new_param_num))
@@ -145,10 +131,8 @@ def _adbc_ast_transformer(expression: Any, parameters: Any) -> tuple[Any, Any]:
 
         return node
 
-    # Transform the AST
     modified_expression = expression.transform(transform_node)
 
-    # Remove NULL parameters from the parameter list
     cleaned_params: Any
     if isinstance(parameters, (list, tuple)):
         cleaned_params = [p for i, p in enumerate(parameters) if i not in null_positions]
@@ -167,7 +151,7 @@ def _adbc_ast_transformer(expression: Any, parameters: Any) -> tuple[Any, Any]:
 
 
 def get_adbc_statement_config(detected_dialect: str) -> StatementConfig:
-    """Create ADBC statement configuration for the specified dialect."""
+    """Create statement configuration for the specified dialect."""
     default_style, supported_styles = DIALECT_PARAMETER_STYLES.get(
         detected_dialect, (ParameterStyle.QMARK, [ParameterStyle.QMARK])
     )
@@ -199,14 +183,14 @@ def get_adbc_statement_config(detected_dialect: str) -> StatementConfig:
 
 
 def _convert_array_for_postgres_adbc(value: Any) -> Any:
-    """Convert array values for PostgreSQL ADBC compatibility."""
+    """Convert array values for PostgreSQL compatibility."""
     if isinstance(value, tuple):
         return list(value)
     return value
 
 
 def get_type_coercion_map(dialect: str) -> "dict[type, Any]":
-    """Get type coercion map for Arrow/ADBC type handling."""
+    """Get type coercion map for Arrow type handling."""
     type_map = {
         datetime.datetime: lambda x: x,
         datetime.date: lambda x: x,
@@ -229,7 +213,7 @@ def get_type_coercion_map(dialect: str) -> "dict[type, Any]":
 
 
 class AdbcCursor:
-    """Context manager for ADBC cursor management."""
+    """Context manager for cursor management."""
 
     __slots__ = ("connection", "cursor")
 
@@ -249,7 +233,7 @@ class AdbcCursor:
 
 
 class AdbcExceptionHandler:
-    """Custom sync context manager for handling ADBC database exceptions."""
+    """Context manager for handling database exceptions."""
 
     __slots__ = ()
 
@@ -265,23 +249,23 @@ class AdbcExceptionHandler:
 
             if issubclass(exc_type, IntegrityError):
                 e = exc_val
-                msg = f"ADBC integrity constraint violation: {e}"
+                msg = f"Integrity constraint violation: {e}"
                 raise SQLSpecError(msg) from e
             if issubclass(exc_type, ProgrammingError):
                 e = exc_val
                 error_msg = str(e).lower()
                 if "syntax" in error_msg or "parse" in error_msg:
-                    msg = f"ADBC SQL syntax error: {e}"
+                    msg = f"SQL syntax error: {e}"
                     raise SQLParsingError(msg) from e
-                msg = f"ADBC programming error: {e}"
+                msg = f"Programming error: {e}"
                 raise SQLSpecError(msg) from e
             if issubclass(exc_type, OperationalError):
                 e = exc_val
-                msg = f"ADBC operational error: {e}"
+                msg = f"Operational error: {e}"
                 raise SQLSpecError(msg) from e
             if issubclass(exc_type, DatabaseError):
                 e = exc_val
-                msg = f"ADBC database error: {e}"
+                msg = f"Database error: {e}"
                 raise SQLSpecError(msg) from e
         except ImportError:
             pass
@@ -298,11 +282,9 @@ class AdbcExceptionHandler:
 class AdbcDriver(SyncDriverAdapterBase):
     """ADBC driver for Arrow Database Connectivity.
 
-    Provides database connectivity through ADBC with support for:
-    - Multi-database dialect support with automatic detection
-    - Arrow-native data handling with type coercion
-    - Parameter style conversion for different backends
-    - Transaction management with proper error handling
+    Provides database connectivity through ADBC with multi-database dialect
+    support, Arrow-native data handling with type coercion, parameter style
+    conversion for different backends, and transaction management.
     """
 
     __slots__ = ("_detected_dialect", "dialect")
@@ -318,17 +300,16 @@ class AdbcDriver(SyncDriverAdapterBase):
         if statement_config is None:
             cache_config = get_cache_config()
             base_config = get_adbc_statement_config(self._detected_dialect)
-            enhanced_config = base_config.replace(
+            statement_config = base_config.replace(
                 enable_caching=cache_config.compiled_cache_enabled, enable_parsing=True, enable_validation=True
             )
-            statement_config = enhanced_config
 
         super().__init__(connection=connection, statement_config=statement_config, driver_features=driver_features)
         self.dialect = statement_config.dialect
 
     @staticmethod
     def _ensure_pyarrow_installed() -> None:
-        """Ensure PyArrow is installed for Arrow operations."""
+        """Ensure PyArrow is installed."""
         from sqlspec.typing import PYARROW_INSTALLED
 
         if not PYARROW_INSTALLED:
@@ -336,7 +317,7 @@ class AdbcDriver(SyncDriverAdapterBase):
 
     @staticmethod
     def _get_dialect(connection: "AdbcConnection") -> str:
-        """Detect database dialect from ADBC connection information."""
+        """Detect database dialect from connection information."""
         try:
             driver_info = connection.adbc_get_info()
             vendor_name = driver_info.get("vendor_name", "").lower()
@@ -344,12 +325,12 @@ class AdbcDriver(SyncDriverAdapterBase):
 
             for dialect, patterns in DIALECT_PATTERNS.items():
                 if any(pattern in vendor_name or pattern in driver_name for pattern in patterns):
-                    logger.debug("ADBC dialect detected: %s (from %s/%s)", dialect, vendor_name, driver_name)
+                    logger.debug("Dialect detected: %s (from %s/%s)", dialect, vendor_name, driver_name)
                     return dialect
         except Exception as e:
-            logger.debug("ADBC dialect detection failed: %s", e)
+            logger.debug("Dialect detection failed: %s", e)
 
-        logger.warning("Could not reliably determine ADBC dialect from driver info. Defaulting to 'postgres'.")
+        logger.warning("Could not determine dialect from driver info. Defaulting to 'postgres'.")
         return "postgres"
 
     def _handle_postgres_rollback(self, cursor: "Cursor") -> None:
@@ -357,7 +338,7 @@ class AdbcDriver(SyncDriverAdapterBase):
         if self.dialect == "postgres":
             with contextlib.suppress(Exception):
                 cursor.execute("ROLLBACK")
-                logger.debug("PostgreSQL rollback executed after ADBC transaction failure")
+                logger.debug("PostgreSQL rollback executed after transaction failure")
 
     def _handle_postgres_empty_parameters(self, parameters: Any) -> Any:
         """Process empty parameters for PostgreSQL compatibility."""
@@ -366,7 +347,7 @@ class AdbcDriver(SyncDriverAdapterBase):
         return parameters
 
     def with_cursor(self, connection: "AdbcConnection") -> "AdbcCursor":
-        """Create context manager for ADBC cursor."""
+        """Create context manager for cursor."""
         return AdbcCursor(connection)
 
     def handle_database_exceptions(self) -> "AbstractContextManager[None]":
@@ -374,10 +355,10 @@ class AdbcDriver(SyncDriverAdapterBase):
         return AdbcExceptionHandler()
 
     def _try_special_handling(self, cursor: "Cursor", statement: SQL) -> "Optional[SQLResult]":
-        """Handle ADBC-specific operations.
+        """Handle special operations.
 
         Args:
-            cursor: ADBC cursor object
+            cursor: Cursor object
             statement: SQL statement to analyze
 
         Returns:
@@ -387,7 +368,7 @@ class AdbcDriver(SyncDriverAdapterBase):
         return None
 
     def _execute_many(self, cursor: "Cursor", statement: SQL) -> "ExecutionResult":
-        """Execute SQL with multiple parameter sets using batch processing."""
+        """Execute SQL with multiple parameter sets."""
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
 
         try:
@@ -411,13 +392,13 @@ class AdbcDriver(SyncDriverAdapterBase):
 
         except Exception:
             self._handle_postgres_rollback(cursor)
-            logger.exception("ADBC executemany failed")
+            logger.exception("Executemany failed")
             raise
 
         return self.create_execution_result(cursor, rowcount_override=row_count, is_many_result=True)
 
     def _execute_statement(self, cursor: "Cursor", statement: SQL) -> "ExecutionResult":
-        """Execute single SQL statement with ADBC-specific data handling."""
+        """Execute single SQL statement."""
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
 
         try:
@@ -449,7 +430,7 @@ class AdbcDriver(SyncDriverAdapterBase):
         return self.create_execution_result(cursor, rowcount_override=row_count)
 
     def _execute_script(self, cursor: "Cursor", statement: "SQL") -> "ExecutionResult":
-        """Execute SQL script with ADBC-specific transaction handling."""
+        """Execute SQL script."""
         if statement.is_script:
             sql = statement._raw_sql
             prepared_parameters: list[Any] = []
@@ -473,7 +454,7 @@ class AdbcDriver(SyncDriverAdapterBase):
                     last_rowcount = cursor.rowcount
         except Exception:
             self._handle_postgres_rollback(cursor)
-            logger.exception("ADBC script execution failed")
+            logger.exception("Script execution failed")
             raise
 
         return self.create_execution_result(
@@ -490,7 +471,7 @@ class AdbcDriver(SyncDriverAdapterBase):
             with self.with_cursor(self.connection) as cursor:
                 cursor.execute("BEGIN")
         except Exception as e:
-            msg = f"Failed to begin ADBC transaction: {e}"
+            msg = f"Failed to begin transaction: {e}"
             raise SQLSpecError(msg) from e
 
     def rollback(self) -> None:
@@ -499,7 +480,7 @@ class AdbcDriver(SyncDriverAdapterBase):
             with self.with_cursor(self.connection) as cursor:
                 cursor.execute("ROLLBACK")
         except Exception as e:
-            msg = f"Failed to rollback ADBC transaction: {e}"
+            msg = f"Failed to rollback transaction: {e}"
             raise SQLSpecError(msg) from e
 
     def commit(self) -> None:
@@ -508,5 +489,5 @@ class AdbcDriver(SyncDriverAdapterBase):
             with self.with_cursor(self.connection) as cursor:
                 cursor.execute("COMMIT")
         except Exception as e:
-            msg = f"Failed to commit ADBC transaction: {e}"
+            msg = f"Failed to commit transaction: {e}"
             raise SQLSpecError(msg) from e

sqlspec/adapters/aiosqlite/config.py

@@ -1,4 +1,4 @@
-"""Aiosqlite database configuration with optimized connection management."""
+"""Aiosqlite database configuration."""
 
 import logging
 from contextlib import asynccontextmanager
@@ -61,7 +61,7 @@ class AiosqliteConfig(AsyncDatabaseConfig["AiosqliteConnection", AiosqliteConnec
         pool_instance: "Optional[AiosqliteConnectionPool]" = None,
         migration_config: "Optional[dict[str, Any]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
-        **kwargs: Any,
+        driver_features: "Optional[dict[str, Any]]" = None,
     ) -> None:
         """Initialize AioSQLite configuration.
 
@@ -70,12 +70,10 @@ class AiosqliteConfig(AsyncDatabaseConfig["AiosqliteConnection", AiosqliteConnec
             pool_instance: Optional pre-configured connection pool instance.
             migration_config: Optional migration configuration.
             statement_config: Optional statement configuration.
-            **kwargs: Additional connection parameters that override pool_config.
+            driver_features: Optional driver feature configuration.
         """
         config_dict = dict(pool_config) if pool_config else {}
-        config_dict.update(kwargs)  # Allow kwargs to override pool_config values
 
-        # Handle memory database URI conversion - test expectation is different than sqlite pattern
         if "database" not in config_dict or config_dict["database"] == ":memory:":
             config_dict["database"] = "file::memory:?cache=shared"
             config_dict["uri"] = True
@@ -85,7 +83,7 @@ class AiosqliteConfig(AsyncDatabaseConfig["AiosqliteConnection", AiosqliteConnec
             pool_instance=pool_instance,
             migration_config=migration_config,
             statement_config=statement_config or aiosqlite_statement_config,
-            driver_features={},
+            driver_features=driver_features or {},
         )
 
     def _get_pool_config_dict(self) -> "dict[str, Any]":
@@ -105,7 +103,7 @@ class AiosqliteConfig(AsyncDatabaseConfig["AiosqliteConnection", AiosqliteConnec
         Returns:
             Dictionary with connection parameters for creating connections.
         """
-        # Filter out all pool-specific parameters that aiosqlite.connect() doesn't accept
+
         excluded_keys = {
             "pool_size",
             "connect_timeout",
@@ -201,9 +199,6 @@ class AiosqliteConfig(AsyncDatabaseConfig["AiosqliteConnection", AiosqliteConnec
     def get_signature_namespace(self) -> "dict[str, type[Any]]":
         """Get the signature namespace for aiosqlite types.
 
-        This provides all aiosqlite-specific types that Litestar needs to recognize
-        to avoid serialization attempts.
-
         Returns:
             Dictionary mapping type names to types.
         """

sqlspec/adapters/aiosqlite/driver.py

@@ -1,11 +1,4 @@
-"""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
-"""
+"""AIOSQLite driver implementation for async SQLite operations."""
 
 import asyncio
 import contextlib
@@ -61,7 +54,7 @@ aiosqlite_statement_config = StatementConfig(
 
 
 class AiosqliteCursor:
-    """Async context manager for AIOSQLite cursor management."""
+    """Async context manager for AIOSQLite cursors."""
 
     __slots__ = ("connection", "cursor")
 
@@ -81,7 +74,7 @@ class AiosqliteCursor:
 
 
 class AiosqliteExceptionHandler:
-    """Custom async context manager for handling AIOSQLite database exceptions."""
+    """Async context manager for AIOSQLite database exceptions."""
 
     __slots__ = ()
 
@@ -125,13 +118,7 @@ class AiosqliteExceptionHandler:
 
 
 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
-    """
+    """AIOSQLite driver for async SQLite database operations."""
 
     __slots__ = ()
     dialect = "sqlite"
@@ -170,7 +157,7 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
         return None
 
     async def _execute_script(self, cursor: "aiosqlite.Cursor", statement: "SQL") -> "ExecutionResult":
-        """Execute SQL script using statement splitting and parameter handling."""
+        """Execute SQL script."""
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
         statements = self.split_script_statements(sql, statement.statement_config, strip_trailing_semicolon=True)
 
@@ -186,7 +173,7 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
         )
 
     async def _execute_many(self, cursor: "aiosqlite.Cursor", statement: "SQL") -> "ExecutionResult":
-        """Execute SQL with multiple parameter sets using async batch processing."""
+        """Execute SQL with multiple parameter sets."""
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
 
         if not prepared_parameters:
@@ -200,7 +187,7 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
         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."""
+        """Execute single SQL statement."""
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
         await cursor.execute(sql, prepared_parameters or ())
 
@@ -218,14 +205,11 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
         return self.create_execution_result(cursor, rowcount_override=affected_rows)
 
     async def begin(self) -> None:
-        """Begin a database transaction with appropriate locking strategy."""
+        """Begin a database transaction."""
         try:
             if not self.connection.in_transaction:
-                # For shared cache databases, use IMMEDIATE to reduce lock contention
-                # For other databases, BEGIN IMMEDIATE is also safer for concurrent access
                 await self.connection.execute("BEGIN IMMEDIATE")
         except aiosqlite.Error as e:
-            # If IMMEDIATE fails due to lock, try with exponential backoff
             import random
 
             max_retries = 3
@@ -235,7 +219,7 @@ class AiosqliteDriver(AsyncDriverAdapterBase):
                 try:
                     await self.connection.execute("BEGIN IMMEDIATE")
                 except aiosqlite.Error:
-                    if attempt == max_retries - 1:  # Last attempt
+                    if attempt == max_retries - 1:
                         break
                 else:
                     return