feat: cache corrections

Author: cofin

sqlspec/driver/_common.py

@@ -10,11 +10,13 @@
 from sqlspec.parameters.types import TypedParameter
 from sqlspec.statement import SQLResult, Statement, StatementFilter
 from sqlspec.statement.builder import QueryBuilder
+from sqlspec.statement.cache import get_cache_config, sql_cache
 from sqlspec.statement.pipeline import SQLTransformContext, create_pipeline_from_config
 from sqlspec.statement.result import OperationType
 from sqlspec.statement.splitter import split_sql_script
 from sqlspec.statement.sql import SQL, StatementConfig
 from sqlspec.utils.logging import get_logger
+from sqlspec.utils.statement_hashing import hash_sql_statement
 
 if TYPE_CHECKING:
     from sqlspec.typing import StatementParameters
@@ -469,7 +471,7 @@ def _apply_pipeline_transformations(
     def _get_compiled_sql(
         self, statement: "SQL", statement_config: "StatementConfig", flatten_single_params: bool = False
     ) -> tuple[str, Any]:
-        """Get compiled SQL with optimal parameter style (only converts when needed).
+        """Get compiled SQL with optimal parameter style and caching support.
 
         Args:
             statement: SQL statement to compile
@@ -479,6 +481,26 @@ def _get_compiled_sql(
         Returns:
             Tuple of (compiled_sql, parameters)
         """
+
+        # Check if caching is enabled
+        cache_config = get_cache_config()
+        cache_key = None
+        if cache_config.compiled_cache_enabled and statement_config.enable_caching:
+            # Generate cache key that includes parameter style context
+            cache_key = self._generate_compilation_cache_key(statement, statement_config, flatten_single_params)
+
+            # Try cache first
+            cached_result = sql_cache.get(cache_key)
+            if cached_result is not None:
+                sql, params = cached_result
+                # Apply driver parameter preparation to cached params
+                prepared_params = self.prepare_driver_parameters(params, statement_config, is_many=statement.is_many)
+                # Apply output_transformer if configured
+                if statement_config.parameter_config.output_transformer:
+                    sql, prepared_params = statement_config.parameter_config.output_transformer(sql, prepared_params)
+                return sql, prepared_params
+
+        # Determine target parameter style (existing logic)
         if statement.is_script and not statement_config.parameter_config.needs_static_script_compilation:
             target_style = ParameterStyle.STATIC
         elif statement_config.parameter_config.supported_execution_parameter_styles is not None:
@@ -496,7 +518,15 @@ def _get_compiled_sql(
         else:
             # No execution style configuration, use default parameter style for explicit compilation
             target_style = statement_config.parameter_config.default_parameter_style
+
+        # Compile the SQL
         sql, params = statement.compile(placeholder_style=target_style, flatten_single_params=flatten_single_params)
+
+        # Cache the compilation result if caching is enabled (before driver preparation)
+        if cache_key is not None:
+            sql_cache.set(cache_key, (sql, params))
+
+        # Prepare parameters for driver
         prepared_params = self.prepare_driver_parameters(params, statement_config, is_many=statement.is_many)
 
         # Apply output_transformer if configured
@@ -505,6 +535,32 @@ def _get_compiled_sql(
 
         return sql, prepared_params
 
+    def _generate_compilation_cache_key(
+        self, statement: "SQL", config: "StatementConfig", flatten_single_params: bool
+    ) -> str:
+        """Generate cache key that includes all compilation context.
+
+        This method creates a deterministic cache key that includes all factors
+        that affect SQL compilation, preventing cache contamination between
+        different compilation contexts.
+        """
+
+        # Include all factors that affect compilation
+        context_hash = hash(
+            (
+                config.parameter_config.hash(),
+                config.dialect,
+                statement.is_script,
+                statement.is_many,
+                flatten_single_params,
+                bool(config.parameter_config.output_transformer),
+                bool(config.parameter_config.needs_static_script_compilation),
+            )
+        )
+
+        base_hash = hash_sql_statement(statement)
+        return f"compiled:{base_hash}:{context_hash}"
+
     def _create_count_query(self, original_sql: "SQL") -> "SQL":
         """Create a COUNT query from the original SQL statement.
 

sqlspec/parameters/config.py

@@ -48,3 +48,26 @@ def __init__(
         self.output_transformer = output_transformer
         self.needs_static_script_compilation = needs_static_script_compilation
         self.allow_mixed_parameter_styles = allow_mixed_parameter_styles
+
+    def hash(self) -> int:
+        """Generate hash for cache key generation.
+
+        This method creates a deterministic hash of the parameter configuration
+        for use in cache keys, ensuring different parameter configurations
+        don't share cache entries.
+        """
+        # Create tuple of all configuration values that affect compilation
+        config_tuple = (
+            self.default_parameter_style.value if self.default_parameter_style else None,
+            tuple(sorted(s.value for s in self.supported_parameter_styles)) if self.supported_parameter_styles else (),
+            tuple(sorted(s.value for s in self.supported_execution_parameter_styles))
+            if self.supported_execution_parameter_styles
+            else (),
+            self.default_execution_parameter_style.value if self.default_execution_parameter_style else None,
+            self.has_native_list_expansion,
+            bool(self.output_transformer),  # Don't hash the function object itself
+            self.needs_static_script_compilation,
+            self.allow_mixed_parameter_styles,
+            tuple(sorted(str(k) for k in self.type_coercion_map)) if self.type_coercion_map else (),
+        )
+        return hash(config_tuple)

sqlspec/statement/sql.py

@@ -32,6 +32,7 @@
 )
 from sqlspec.typing import Empty
 from sqlspec.utils.logging import get_logger
+from sqlspec.utils.statement_hashing import hash_sql_statement
 from sqlspec.utils.type_guards import (
     can_append_to_statement,
     can_extract_parameters,
@@ -1690,6 +1691,46 @@ def _convert_named_pyformat_parameters(self, params: dict[str, Any], norm_state:
 
         return params
 
+    def generate_cache_key_with_config(self, config: "Optional[StatementConfig]" = None) -> str:
+        """Generate cache key that includes StatementConfig context.
+
+        This method creates a deterministic cache key that includes both the SQL content
+        and the StatementConfig settings to prevent cross-contamination between different
+        configurations.
+
+        Args:
+            config: Optional StatementConfig to use for key generation.
+                   Uses self.statement_config if not provided.
+
+        Returns:
+            String cache key that includes both SQL and configuration context
+        """
+
+        effective_config = config or self.statement_config
+
+        # Create hash of configuration values that affect processing
+        config_hash = hash(
+            (
+                effective_config.enable_parsing,
+                effective_config.enable_validation,
+                effective_config.enable_transformations,
+                effective_config.enable_analysis,
+                effective_config.enable_expression_simplification,
+                effective_config.enable_parameter_type_wrapping,
+                effective_config.enable_caching,
+                effective_config.dialect,
+                effective_config.parameter_config.hash(),
+                tuple(effective_config.pre_process_steps) if effective_config.pre_process_steps else (),
+                tuple(effective_config.post_process_steps) if effective_config.post_process_steps else (),
+            )
+        )
+
+        # Include filter context in the cache key
+        filter_hash = hash(tuple(str(f) for f in self._filters)) if self._filters else 0
+
+        base_hash = hash_sql_statement(self)
+        return f"sql:{base_hash}:{config_hash}:{filter_hash}"
+
     def _apply_placeholder_style(self, sql: "str", params: Any, placeholder_style: "str") -> "tuple[str, Any]":
         """Apply placeholder style conversion using ParameterConverter."""
         target_style = ParameterStyle(placeholder_style) if isinstance(placeholder_style, str) else placeholder_style