sqlspec 0.13.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

sqlspec/driver/_sync.py

@@ -205,17 +205,23 @@ class SyncDriverAdapterProtocol(CommonDriverAttributesMixin[ConnectionT, RowT],
         _config: "Optional[SQLConfig]" = None,
         **kwargs: Any,
     ) -> "SQLResult[RowT]":
-        _filters, param_sequence = process_execute_many_parameters(parameters)
+        """Execute statement multiple times with different parameters.
 
-        # For execute_many, disable transformations to prevent literal extraction
-        # since the SQL already has placeholders for bulk operations
-        many_config = _config or self.config
-        if many_config.enable_transformations:
-            from dataclasses import replace
+        Now passes first parameter set through pipeline to enable
+        literal extraction and consistent parameter processing.
+        """
+        filters, param_sequence = process_execute_many_parameters(parameters)
+
+        # Process first parameter set through pipeline for literal extraction
+        first_params = param_sequence[0] if param_sequence else None
 
-            many_config = replace(many_config, enable_transformations=False)
+        # Build statement with first params to trigger pipeline processing
+        sql_statement = self._build_statement(
+            statement, first_params, *filters, _config=_config or self.config, **kwargs
+        )
 
-        sql_statement = self._build_statement(statement, _config=many_config, **kwargs).as_many(param_sequence)
+        # Mark as many with full sequence
+        sql_statement = sql_statement.as_many(param_sequence)
 
         return self._execute_statement(statement=sql_statement, connection=self._connection(_connection), **kwargs)
 
@@ -226,12 +232,24 @@ class SyncDriverAdapterProtocol(CommonDriverAttributesMixin[ConnectionT, RowT],
         *parameters: "Union[StatementParameters, StatementFilter]",
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
+        _suppress_warnings: bool = False,  # New parameter for migrations
         **kwargs: Any,
     ) -> "SQLResult[RowT]":
+        """Execute a multi-statement script.
+
+        By default, validates each statement and logs warnings for dangerous
+        operations. Use _suppress_warnings=True for migrations and admin scripts.
+        """
         script_config = _config or self.config
-        if script_config.enable_validation:
-            script_config = replace(script_config, enable_validation=False, strict_mode=False)
+
+        # Keep validation enabled by default
+        # Validators will log warnings for dangerous operations
 
         sql_statement = self._build_statement(statement, *parameters, _config=script_config, **kwargs)
         sql_statement = sql_statement.as_script()
+
+        # Pass suppress warnings flag to execution
+        if _suppress_warnings:
+            kwargs["_suppress_warnings"] = True
+
         return self._execute_statement(statement=sql_statement, connection=self._connection(_connection), **kwargs)

sqlspec/driver/mixins/__init__.py

@@ -1,16 +1,22 @@
 """Driver mixins for instrumentation, storage, and utilities."""
 
+from sqlspec.driver.mixins._cache import AsyncAdapterCacheMixin, SyncAdapterCacheMixin
 from sqlspec.driver.mixins._pipeline import AsyncPipelinedExecutionMixin, SyncPipelinedExecutionMixin
+from sqlspec.driver.mixins._query_tools import AsyncQueryMixin, SyncQueryMixin
 from sqlspec.driver.mixins._result_utils import ToSchemaMixin
 from sqlspec.driver.mixins._sql_translator import SQLTranslatorMixin
 from sqlspec.driver.mixins._storage import AsyncStorageMixin, SyncStorageMixin
 from sqlspec.driver.mixins._type_coercion import TypeCoercionMixin
 
 __all__ = (
+    "AsyncAdapterCacheMixin",
     "AsyncPipelinedExecutionMixin",
+    "AsyncQueryMixin",
     "AsyncStorageMixin",
     "SQLTranslatorMixin",
+    "SyncAdapterCacheMixin",
     "SyncPipelinedExecutionMixin",
+    "SyncQueryMixin",
     "SyncStorageMixin",
     "ToSchemaMixin",
     "TypeCoercionMixin",

sqlspec/driver/mixins/_cache.py

@@ -0,0 +1,114 @@
+"""Adapter-level caching mixin for compiled SQL and prepared statements."""
+
+from typing import TYPE_CHECKING, Any, Optional
+
+from sqlspec.statement.cache import SQLCache
+from sqlspec.statement.parameters import ParameterStyle
+
+if TYPE_CHECKING:
+    from sqlspec.statement.sql import SQL
+
+__all__ = ("AsyncAdapterCacheMixin", "SyncAdapterCacheMixin")
+
+
+class SyncAdapterCacheMixin:
+    """Mixin for adapter-level SQL compilation caching.
+
+    This mixin provides:
+    - Compiled SQL caching to avoid repeated compilation
+    - Parameter style conversion caching
+    - Prepared statement name management (for supported databases)
+
+    Integrates transparently with existing adapter execution flow.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Initialize adapter with caching support."""
+        super().__init__(*args, **kwargs)
+
+        # Get cache configuration from config or use defaults
+        config = getattr(self, "config", None)
+        cache_size = getattr(config, "adapter_cache_size", 500) if config else 500
+        enable_cache = getattr(config, "enable_adapter_cache", True) if config else True
+
+        # Initialize caches
+        self._compiled_cache: Optional[SQLCache] = SQLCache(max_size=cache_size) if enable_cache else None
+        self._prepared_statements: dict[str, str] = {}
+        self._prepared_counter = 0
+
+    def _get_compiled_sql(self, statement: "SQL", target_style: ParameterStyle) -> tuple[str, Any]:
+        """Get compiled SQL with caching.
+
+        Args:
+            statement: SQL statement to compile
+            target_style: Target parameter style for compilation
+
+        Returns:
+            Tuple of (compiled_sql, parameters)
+        """
+        if self._compiled_cache is None:
+            # Caching disabled
+            return statement.compile(placeholder_style=target_style)
+
+        # Generate cache key
+        cache_key = self._adapter_cache_key(statement, target_style)
+
+        # Check cache
+        cached = self._compiled_cache.get(cache_key)
+        if cached is not None:
+            return cached  # type: ignore[no-any-return]
+
+        # Compile and cache
+        result = statement.compile(placeholder_style=target_style)
+        self._compiled_cache.set(cache_key, result)
+        return result
+
+    def _adapter_cache_key(self, statement: "SQL", style: ParameterStyle) -> str:
+        """Generate adapter-specific cache key.
+
+        Args:
+            statement: SQL statement
+            style: Parameter style
+
+        Returns:
+            Cache key string
+        """
+        # Use statement's internal cache key which includes SQL hash, params, and dialect
+        base_key = statement._cache_key()
+        # Add adapter-specific context
+        return f"{self.__class__.__name__}:{style.value}:{base_key}"
+
+    def _get_or_create_prepared_statement_name(self, sql_hash: str) -> str:
+        """Get or create a prepared statement name for the given SQL.
+
+        Used by PostgreSQL and other databases that support prepared statements.
+
+        Args:
+            sql_hash: Hash of the SQL statement
+
+        Returns:
+            Prepared statement name
+        """
+        if sql_hash in self._prepared_statements:
+            return self._prepared_statements[sql_hash]
+
+        # Create new prepared statement name
+        self._prepared_counter += 1
+        stmt_name = f"sqlspec_ps_{self._prepared_counter}"
+        self._prepared_statements[sql_hash] = stmt_name
+        return stmt_name
+
+    def _clear_adapter_cache(self) -> None:
+        """Clear all adapter-level caches."""
+        if self._compiled_cache is not None:
+            self._compiled_cache.clear()
+        self._prepared_statements.clear()
+        self._prepared_counter = 0
+
+
+class AsyncAdapterCacheMixin(SyncAdapterCacheMixin):
+    """Async version of AdapterCacheMixin.
+
+    Identical to AdapterCacheMixin since caching operations are synchronous.
+    Provided for naming consistency with async adapters.
+    """

sqlspec/driver/mixins/_pipeline.py

@@ -54,8 +54,6 @@ class PipelineOperation:
 class SyncPipelinedExecutionMixin:
     """Mixin providing pipeline execution for sync drivers."""
 
-    __slots__ = ()
-
     def pipeline(
         self,
         *,
@@ -87,8 +85,6 @@ class SyncPipelinedExecutionMixin:
 class AsyncPipelinedExecutionMixin:
     """Async version of pipeline execution mixin."""
 
-    __slots__ = ()
-
     def pipeline(
         self,
         *,