sqlspec 0.24.1__py3-none-any.whl → 0.25.0__py3-none-any.whl

sqlspec/core/hashing.py

@@ -185,26 +185,24 @@ def hash_sql_statement(statement: "SQL") -> str:
     """
     from sqlspec.utils.type_guards import is_expression
 
-    if is_expression(statement._statement):
-        expr_hash = hash_expression(statement._statement)
-    else:
-        expr_hash = hash(statement._raw_sql)
+    stmt_expr = statement.statement_expression
+    expr_hash = hash_expression(stmt_expr) if is_expression(stmt_expr) else hash(statement.raw_sql)
 
     param_hash = hash_parameters(
-        positional_parameters=statement._positional_parameters,
-        named_parameters=statement._named_parameters,
-        original_parameters=statement._original_parameters,
+        positional_parameters=statement.positional_parameters,
+        named_parameters=statement.named_parameters,
+        original_parameters=statement.original_parameters,
     )
 
-    filter_hash = hash_filters(statement._filters)
+    filter_hash = hash_filters(statement.filters)
 
     state_components = [
         expr_hash,
         param_hash,
         filter_hash,
-        hash(statement._dialect),
-        hash(statement._is_many),
-        hash(statement._is_script),
+        hash(statement.dialect),
+        hash(statement.is_many),
+        hash(statement.is_script),
     ]
 
     return f"sql:{hash(tuple(state_components))}"

sqlspec/core/parameters.py

@@ -755,17 +755,30 @@ class ParameterConverter:
             parameter_styles = {p.style for p in param_info}
             has_mixed_styles = len(parameter_styles) > 1
 
+            # Build unique parameter mapping to avoid duplicates when same parameter appears multiple times
+            unique_params: dict[str, Any] = {}
+            param_order: list[str] = []
+
             if has_mixed_styles:
                 param_keys = list(parameters.keys())
                 for param in param_info:
-                    value, found = self._extract_param_value_mixed_styles(param, parameters, param_keys)
-                    if found:
-                        param_values.append(value)
+                    param_key = param.placeholder_text
+                    if param_key not in unique_params:
+                        value, found = self._extract_param_value_mixed_styles(param, parameters, param_keys)
+                        if found:
+                            unique_params[param_key] = value
+                            param_order.append(param_key)
             else:
                 for param in param_info:
-                    value, found = self._extract_param_value_single_style(param, parameters)
-                    if found:
-                        param_values.append(value)
+                    param_key = param.placeholder_text
+                    if param_key not in unique_params:
+                        value, found = self._extract_param_value_single_style(param, parameters)
+                        if found:
+                            unique_params[param_key] = value
+                            param_order.append(param_key)
+
+            # Build parameter values list from unique parameters in order
+            param_values = [unique_params[param_key] for param_key in param_order]
 
             if preserve_parameter_format and original_parameters is not None:
                 return self._preserve_original_format(param_values, original_parameters)
@@ -1064,7 +1077,7 @@ class ParameterProcessor:
 
         return processed_sql, processed_parameters
 
-    def _get_sqlglot_compatible_sql(
+    def get_sqlglot_compatible_sql(
         self, sql: str, parameters: Any, config: ParameterStyleConfig, dialect: Optional[str] = None
     ) -> "tuple[str, Any]":
         """Get SQL normalized for parsing only (Phase 1 only).

sqlspec/core/statement.py

@@ -18,6 +18,7 @@ from sqlspec.utils.type_guards import is_statement_filter, supports_where
 if TYPE_CHECKING:
     from sqlglot.dialects.dialect import DialectType
 
+    from sqlspec.core.cache import FiltersView
     from sqlspec.core.filters import StatementFilter
 
 
@@ -161,14 +162,14 @@ class SQL:
         self._process_parameters(*parameters, **kwargs)
 
     def _create_auto_config(
-        self, statement: "Union[str, exp.Expression, 'SQL']", parameters: tuple, kwargs: dict[str, Any]
+        self, _statement: "Union[str, exp.Expression, 'SQL']", _parameters: tuple, _kwargs: dict[str, Any]
     ) -> "StatementConfig":
         """Create default StatementConfig when none provided.
 
         Args:
-            statement: The SQL statement
-            parameters: Statement parameters
-            kwargs: Additional keyword arguments
+            _statement: The SQL statement (unused)
+            _parameters: Statement parameters (unused)
+            _kwargs: Additional keyword arguments (unused)
 
         Returns:
             Default StatementConfig instance
@@ -196,14 +197,14 @@ class SQL:
         Args:
             sql_obj: Existing SQL object to copy from
         """
-        self._raw_sql = sql_obj._raw_sql
-        self._filters = sql_obj._filters.copy()
-        self._named_parameters = sql_obj._named_parameters.copy()
-        self._positional_parameters = sql_obj._positional_parameters.copy()
-        self._is_many = sql_obj._is_many
-        self._is_script = sql_obj._is_script
-        if sql_obj._processed_state is not Empty:
-            self._processed_state = sql_obj._processed_state
+        self._raw_sql = sql_obj.raw_sql
+        self._filters = sql_obj.filters.copy()
+        self._named_parameters = sql_obj.named_parameters.copy()
+        self._positional_parameters = sql_obj.positional_parameters.copy()
+        self._is_many = sql_obj.is_many
+        self._is_script = sql_obj.is_script
+        if sql_obj.is_processed:
+            self._processed_state = sql_obj.get_processed_state()
 
     def _should_auto_detect_many(self, parameters: tuple) -> bool:
         """Detect execute_many mode from parameter structure.
@@ -270,6 +271,15 @@ class SQL:
         """Get the raw SQL string."""
         return self._raw_sql
 
+    @property
+    def raw_sql(self) -> str:
+        """Get raw SQL string (public API).
+
+        Returns:
+            The raw SQL string
+        """
+        return self._raw_sql
+
     @property
     def parameters(self) -> Any:
         """Get the original parameters."""
@@ -277,6 +287,21 @@ class SQL:
             return self._named_parameters
         return self._positional_parameters or []
 
+    @property
+    def positional_parameters(self) -> "list[Any]":
+        """Get positional parameters (public API)."""
+        return self._positional_parameters or []
+
+    @property
+    def named_parameters(self) -> "dict[str, Any]":
+        """Get named parameters (public API)."""
+        return self._named_parameters
+
+    @property
+    def original_parameters(self) -> Any:
+        """Get original parameters (public API)."""
+        return self._original_parameters
+
     @property
     def operation_type(self) -> "OperationType":
         """SQL operation type."""
@@ -301,6 +326,25 @@ class SQL:
         """Applied filters."""
         return self._filters.copy()
 
+    def get_filters_view(self) -> "FiltersView":
+        """Get zero-copy filters view (public API).
+
+        Returns:
+            Read-only view of filters without copying
+        """
+        from sqlspec.core.cache import FiltersView
+
+        return FiltersView(self._filters)
+
+    @property
+    def is_processed(self) -> bool:
+        """Check if SQL has been processed (public API)."""
+        return self._processed_state is not Empty
+
+    def get_processed_state(self) -> Any:
+        """Get processed state (public API)."""
+        return self._processed_state
+
     @property
     def dialect(self) -> "Optional[str]":
         """SQL dialect."""
@@ -311,6 +355,17 @@ class SQL:
         """Internal SQLGlot expression."""
         return self.expression
 
+    @property
+    def statement_expression(self) -> "Optional[exp.Expression]":
+        """Get parsed statement expression (public API).
+
+        Returns:
+            Parsed SQLGlot expression or None if not parsed
+        """
+        if self._processed_state is not Empty:
+            return self._processed_state.parsed_expression
+        return None
+
     @property
     def is_many(self) -> bool:
         """Check if this is execute_many."""

sqlspec/driver/_async.py

@@ -186,10 +186,10 @@ class AsyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, To
         config = statement_config or self.statement_config
 
         if isinstance(statement, SQL):
-            sql_statement = SQL(statement._raw_sql, parameters, statement_config=config, is_many=True, **kwargs)
+            sql_statement = SQL(statement.raw_sql, parameters, statement_config=config, is_many=True, **kwargs)
         else:
             base_statement = self.prepare_statement(statement, filters, statement_config=config, kwargs=kwargs)
-            sql_statement = SQL(base_statement._raw_sql, parameters, statement_config=config, is_many=True, **kwargs)
+            sql_statement = SQL(base_statement.raw_sql, parameters, statement_config=config, is_many=True, **kwargs)
 
         return await self.dispatch_statement_execution(statement=sql_statement, connection=self.connection)
 

sqlspec/driver/_common.py

@@ -7,7 +7,7 @@ from sqlglot import exp
 
 from sqlspec.builder import QueryBuilder
 from sqlspec.core import SQL, ParameterStyle, SQLResult, Statement, StatementConfig, TypedParameter
-from sqlspec.core.cache import get_cache_config, sql_cache
+from sqlspec.core.cache import CachedStatement, get_cache, get_cache_config
 from sqlspec.core.splitter import split_sql_script
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.utils.logging import get_logger
@@ -206,16 +206,16 @@ class CommonDriverAttributesMixin:
             sql_statement = statement.to_statement(statement_config)
             if parameters or kwargs:
                 merged_parameters = (
-                    (*sql_statement._positional_parameters, *parameters)
+                    (*sql_statement.positional_parameters, *parameters)
                     if parameters
-                    else sql_statement._positional_parameters
+                    else sql_statement.positional_parameters
                 )
                 return SQL(sql_statement.sql, *merged_parameters, statement_config=statement_config, **kwargs)
             return sql_statement
         if isinstance(statement, SQL):
             if parameters or kwargs:
                 merged_parameters = (
-                    (*statement._positional_parameters, *parameters) if parameters else statement._positional_parameters
+                    (*statement.positional_parameters, *parameters) if parameters else statement.positional_parameters
                 )
                 return SQL(statement.sql, *merged_parameters, statement_config=statement_config, **kwargs)
             needs_rebuild = False
@@ -232,14 +232,14 @@ class CommonDriverAttributesMixin:
                 needs_rebuild = True
 
             if needs_rebuild:
-                sql_text = statement._raw_sql or statement.sql
+                sql_text = statement.raw_sql or statement.sql
 
                 if statement.is_many and statement.parameters:
                     new_sql = SQL(sql_text, statement.parameters, statement_config=statement_config, is_many=True)
-                elif statement._named_parameters:
-                    new_sql = SQL(sql_text, statement_config=statement_config, **statement._named_parameters)
+                elif statement.named_parameters:
+                    new_sql = SQL(sql_text, statement_config=statement_config, **statement.named_parameters)
                 else:
-                    new_sql = SQL(sql_text, *statement._positional_parameters, statement_config=statement_config)
+                    new_sql = SQL(sql_text, *statement.positional_parameters, statement_config=statement_config)
 
                 return new_sql
             return statement
@@ -413,9 +413,10 @@ class CommonDriverAttributesMixin:
         cache_key = None
         if cache_config.compiled_cache_enabled and statement_config.enable_caching:
             cache_key = self._generate_compilation_cache_key(statement, statement_config, flatten_single_parameters)
-            cached_result = sql_cache.get(cache_key)
-            if cached_result is not None:
-                return cached_result
+            cache = get_cache()
+            cached_result = cache.get("statement", cache_key, str(statement.dialect) if statement.dialect else None)
+            if cached_result is not None and isinstance(cached_result, CachedStatement):
+                return cached_result.compiled_sql, cached_result.parameters
 
         prepared_statement = self.prepare_statement(statement, statement_config=statement_config)
         compiled_sql, execution_parameters = prepared_statement.compile()
@@ -430,7 +431,23 @@ class CommonDriverAttributesMixin:
             )
 
         if cache_key is not None:
-            sql_cache.set(cache_key, (compiled_sql, prepared_parameters))
+            cache = get_cache()
+            cached_statement = CachedStatement(
+                compiled_sql=compiled_sql,
+                parameters=tuple(prepared_parameters)
+                if isinstance(prepared_parameters, list)
+                else (
+                    prepared_parameters
+                    if prepared_parameters is None
+                    else (
+                        tuple(prepared_parameters)
+                        if not isinstance(prepared_parameters, tuple)
+                        else prepared_parameters
+                    )
+                ),
+                expression=statement.expression,
+            )
+            cache.put("statement", cache_key, cached_statement, str(statement.dialect) if statement.dialect else None)
 
         return compiled_sql, prepared_parameters
 
@@ -562,8 +579,8 @@ class CommonDriverAttributesMixin:
             count_expr.set("limit", None)
             count_expr.set("offset", None)
 
-            return SQL(count_expr, *original_sql._positional_parameters, statement_config=original_sql.statement_config)
+            return SQL(count_expr, *original_sql.positional_parameters, statement_config=original_sql.statement_config)
 
         subquery = cast("exp.Select", expr).subquery(alias="total_query")
         count_expr = exp.select(exp.Count(this=exp.Star())).from_(subquery)
-        return SQL(count_expr, *original_sql._positional_parameters, statement_config=original_sql.statement_config)
+        return SQL(count_expr, *original_sql.positional_parameters, statement_config=original_sql.statement_config)

sqlspec/driver/_sync.py

@@ -186,10 +186,10 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         config = statement_config or self.statement_config
 
         if isinstance(statement, SQL):
-            sql_statement = SQL(statement._raw_sql, parameters, statement_config=config, is_many=True, **kwargs)
+            sql_statement = SQL(statement.raw_sql, parameters, statement_config=config, is_many=True, **kwargs)
         else:
             base_statement = self.prepare_statement(statement, filters, statement_config=config, kwargs=kwargs)
-            sql_statement = SQL(base_statement._raw_sql, parameters, statement_config=config, is_many=True, **kwargs)
+            sql_statement = SQL(base_statement.raw_sql, parameters, statement_config=config, is_many=True, **kwargs)
 
         return self.dispatch_statement_execution(statement=sql_statement, connection=self.connection)
 

sqlspec/driver/mixins/_result_tools.py

@@ -15,6 +15,7 @@ from mypy_extensions import trait
 from sqlspec.exceptions import SQLSpecError
 from sqlspec.typing import (
     CATTRS_INSTALLED,
+    NUMPY_INSTALLED,
     ModelDTOT,
     ModelT,
     attrs_asdict,
@@ -41,12 +42,36 @@ logger = logging.getLogger(__name__)
 
 
 _DATETIME_TYPES: Final[set[type]] = {datetime.datetime, datetime.date, datetime.time}
+
+
+def _is_list_type_target(target_type: Any) -> bool:
+    """Check if target type is a list type (e.g., list[float])."""
+    try:
+        return hasattr(target_type, "__origin__") and target_type.__origin__ is list
+    except (AttributeError, TypeError):
+        return False
+
+
+def _convert_numpy_to_list(target_type: Any, value: Any) -> Any:
+    """Convert numpy array to list if target is a list type."""
+    if not NUMPY_INSTALLED:
+        return value
+
+    import numpy as np
+
+    if isinstance(value, np.ndarray) and _is_list_type_target(target_type):
+        return value.tolist()
+
+    return value
+
+
 _DEFAULT_TYPE_DECODERS: Final[list[tuple[Callable[[Any], bool], Callable[[Any, Any], Any]]]] = [
     (lambda x: x is UUID, lambda t, v: t(v.hex)),
     (lambda x: x is datetime.datetime, lambda t, v: t(v.isoformat())),
     (lambda x: x is datetime.date, lambda t, v: t(v.isoformat())),
     (lambda x: x is datetime.time, lambda t, v: t(v.isoformat())),
     (lambda x: x is Enum, lambda t, v: t(v.value)),
+    (_is_list_type_target, _convert_numpy_to_list),
 ]
 
 
@@ -63,6 +88,13 @@ def _default_msgspec_deserializer(
     Returns:
         Converted value or original value if conversion not applicable
     """
+    # Handle numpy arrays first for list types
+    if NUMPY_INSTALLED:
+        import numpy as np
+
+        if isinstance(value, np.ndarray) and _is_list_type_target(target_type):
+            return value.tolist()
+
     if type_decoders:
         for predicate, decoder in type_decoders:
             if predicate(target_type):
@@ -71,17 +103,19 @@ def _default_msgspec_deserializer(
     if target_type is UUID and isinstance(value, UUID):
         return value.hex
 
-    if target_type in _DATETIME_TYPES:
-        try:
-            return value.isoformat()
-        except AttributeError:
-            pass
+    if target_type in _DATETIME_TYPES and hasattr(value, "isoformat"):
+        return value.isoformat()  # pyright: ignore
 
     if isinstance(target_type, type) and issubclass(target_type, Enum) and isinstance(value, Enum):
         return value.value
 
-    if isinstance(value, target_type):
-        return value
+    # Check if value is already the correct type (but avoid parameterized generics)
+    try:
+        if isinstance(target_type, type) and isinstance(value, target_type):
+            return value
+    except TypeError:
+        # Handle parameterized generics like list[int] which can't be used with isinstance
+        pass
 
     if isinstance(target_type, type):
         try:
@@ -190,6 +224,25 @@ class ToSchemaMixin:
                     logger.debug("Field name transformation failed for msgspec schema: %s", e)
                     transformed_data = data
 
+            # Pre-process numpy arrays to lists before msgspec conversion
+            if NUMPY_INSTALLED:
+                try:
+                    import numpy as np
+
+                    def _convert_numpy_arrays_in_data(obj: Any) -> Any:
+                        """Recursively convert numpy arrays to lists in data structures."""
+                        if isinstance(obj, np.ndarray):
+                            return obj.tolist()
+                        if isinstance(obj, dict):
+                            return {k: _convert_numpy_arrays_in_data(v) for k, v in obj.items()}
+                        if isinstance(obj, (list, tuple)):
+                            return type(obj)(_convert_numpy_arrays_in_data(item) for item in obj)
+                        return obj
+
+                    transformed_data = _convert_numpy_arrays_in_data(transformed_data)
+                except ImportError:
+                    pass
+
             if not isinstance(transformed_data, Sequence):
                 return convert(obj=transformed_data, type=schema_type, from_attributes=True, dec_hook=deserializer)
             return convert(obj=transformed_data, type=list[schema_type], from_attributes=True, dec_hook=deserializer)  # type: ignore[valid-type]

sqlspec/loader.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, Final, Optional, Union
 from urllib.parse import unquote, urlparse
 
-from sqlspec.core.cache import CacheKey, get_cache_config, get_default_cache
+from sqlspec.core.cache import get_cache, get_cache_config
 from sqlspec.core.statement import SQL
 from sqlspec.exceptions import SQLFileNotFoundError, SQLFileParseError, StorageOperationFailedError
 from sqlspec.storage.registry import storage_registry as default_storage_registry
@@ -438,9 +438,8 @@ class SQLFileLoader:
             return
 
         cache_key_str = self._generate_file_cache_key(file_path)
-        cache_key = CacheKey((cache_key_str,))
-        unified_cache = get_default_cache()
-        cached_file = unified_cache.get(cache_key)
+        cache = get_cache()
+        cached_file = cache.get("file", cache_key_str)
 
         if (
             cached_file is not None
@@ -475,7 +474,7 @@ class SQLFileLoader:
                     file_statements[stored_name] = self._queries[query_name]
 
             cached_file_data = CachedSQLFile(sql_file=sql_file, parsed_statements=file_statements)
-            unified_cache.put(cache_key, cached_file_data)
+            cache.put("file", cache_key_str, cached_file_data)
 
     def _load_file_without_cache(self, file_path: Union[str, Path], namespace: Optional[str]) -> None:
         """Load a single SQL file without using cache.
@@ -592,15 +591,15 @@ class SQLFileLoader:
 
         cache_config = get_cache_config()
         if cache_config.compiled_cache_enabled:
-            unified_cache = get_default_cache()
-            unified_cache.clear()
+            cache = get_cache()
+            cache.clear()
 
     def clear_file_cache(self) -> None:
         """Clear the file cache only, keeping loaded queries."""
         cache_config = get_cache_config()
         if cache_config.compiled_cache_enabled:
-            unified_cache = get_default_cache()
-            unified_cache.clear()
+            cache = get_cache()
+            cache.clear()
 
     def get_query_text(self, name: str) -> str:
         """Get raw SQL text for a query.

sqlspec/storage/backends/fsspec.py

@@ -1,3 +1,4 @@
+# pyright: reportPrivateUsage=false
 import logging
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Optional, Union

sqlspec/typing.py

@@ -12,6 +12,7 @@ from sqlspec._typing import (
     FSSPEC_INSTALLED,
     LITESTAR_INSTALLED,
     MSGSPEC_INSTALLED,
+    NUMPY_INSTALLED,
     OBSTORE_INSTALLED,
     OPENTELEMETRY_INSTALLED,
     PGVECTOR_INSTALLED,
@@ -187,6 +188,7 @@ __all__ = (
     "FSSPEC_INSTALLED",
     "LITESTAR_INSTALLED",
     "MSGSPEC_INSTALLED",
+    "NUMPY_INSTALLED",
     "OBSTORE_INSTALLED",
     "OPENTELEMETRY_INSTALLED",
     "PGVECTOR_INSTALLED",

{sqlspec-0.24.1.dist-info → sqlspec-0.25.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.24.1
+Version: 0.25.0
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/