sqlspec 0.48.0__tar.gz → 0.48.1__tar.gz

{sqlspec-0.48.0 → sqlspec-0.48.1}/PKG-INFO

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

{sqlspec-0.48.0 → sqlspec-0.48.1}/pyproject.toml

@@ -24,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.48.0"
+version = "0.48.1"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -193,6 +193,7 @@ packages = ["sqlspec"]
 packages = []
 
 
+
 [tool.hatch.build.targets.wheel.hooks.mypyc]
 dependencies = ["hatch-mypyc", "hatch-cython", "mypy>=2.0.0"]
 enable-by-default = false
@@ -292,7 +293,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.48.0"
+current_version = "0.48.1"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.48.0 → sqlspec-0.48.1}/sqlspec/core/filters.py

@@ -154,6 +154,33 @@ class StatementFilter(ABC):
             return f"expr_{str(hash(name)).replace('-', '')[:8]}"
         return name.replace(".", "_")
 
+    def _reconstruction_args(self) -> "tuple[Any, ...]":
+        """Return the positional ``__init__`` args needed to rebuild this filter.
+
+        Subclasses must override this to support :func:`copy.deepcopy` and :mod:`pickle`.
+        The default raises only when reconstruction is actually attempted, so filters
+        that never need to be copied or pickled don't pay an implementation cost.
+        """
+        msg = (
+            f"{type(self).__name__} does not implement _reconstruction_args(); "
+            "override it to support copy.deepcopy and pickle"
+        )
+        raise NotImplementedError(msg)
+
+    def __reduce__(self) -> "tuple[Any, ...]":
+        """Reconstruct via ``cls(*ctor_args)`` — works on mypyc native classes."""
+        return (type(self), self._reconstruction_args())
+
+    def __eq__(self, other: object) -> bool:
+        """Compare filters by their cache key for round-trip and deduplication checks."""
+        if not isinstance(other, StatementFilter):
+            return NotImplemented
+        return self.get_cache_key() == other.get_cache_key()
+
+    def __hash__(self) -> int:
+        """Hash via the canonical filter key so unhashable members are normalized."""
+        return hash(_canonical_filter_key(self))
+
     @abstractmethod
     def get_cache_key(self) -> "tuple[Any, ...]":
         """Return a cache key for this filter's configuration.
@@ -245,6 +272,9 @@ class BeforeAfterFilter(StatementFilter):
         """Return cache key for this filter configuration."""
         return ("BeforeAfterFilter", self.field_name, self.before, self.after)
 
+    def _reconstruction_args(self) -> "tuple[Any, ...]":
+        return (self._field_name, self._before, self._after)
+
 
 class OnBeforeAfterFilter(StatementFilter):
     """Filter for inclusive datetime range queries.
@@ -330,6 +360,9 @@ class OnBeforeAfterFilter(StatementFilter):
         """Return cache key for this filter configuration."""
         return ("OnBeforeAfterFilter", self.field_name, self.on_or_before, self.on_or_after)
 
+    def _reconstruction_args(self) -> "tuple[Any, ...]":
+        return (self._field_name, self._on_or_before, self._on_or_after)
+
 
 class InAnyFilter(StatementFilter, ABC, Generic[T]):
     """Base class for collection-based filters that support ANY operations."""
@@ -405,6 +438,9 @@ class InAnyFilter(StatementFilter, ABC, Generic[T]):
         values_tuple = tuple(self.values) if self.values is not None else None
         return (self._cache_key_name, self.field_name, values_tuple)
 
+    def _reconstruction_args(self) -> "tuple[Any, ...]":
+        return (self._field_name, self._values)
+
 
 class InCollectionFilter(InAnyFilter[T]):
     """Filter for IN clause queries.
@@ -529,6 +565,9 @@ class LimitOffsetFilter(PaginationFilter):
         """Return cache key for this filter configuration."""
         return ("LimitOffsetFilter", self.limit, self.offset)
 
+    def _reconstruction_args(self) -> "tuple[Any, ...]":
+        return (self._limit, self._offset)
+
 
 class OrderByFilter(StatementFilter):
     """Filter for ORDER BY clauses.
@@ -587,6 +626,9 @@ class OrderByFilter(StatementFilter):
         """Return cache key for this filter configuration."""
         return ("OrderByFilter", self.field_name, self.sort_order)
 
+    def _reconstruction_args(self) -> "tuple[Any, ...]":
+        return (self._field_name, self._sort_order)
+
 
 class SearchFilter(StatementFilter):
     """Filter for text search queries.
@@ -712,6 +754,9 @@ class SearchFilter(StatementFilter):
             field_names = self.field_name
         return ("SearchFilter", field_names, self.value, self.ignore_case)
 
+    def _reconstruction_args(self) -> "tuple[Any, ...]":
+        return (self._field_name, self._value, self._ignore_case)
+
 
 class NullFilter(StatementFilter):
     """Filter for IS NULL queries.
@@ -745,6 +790,9 @@ class NullFilter(StatementFilter):
         """Return cache key for this filter configuration."""
         return ("NullFilter", self.field_name)
 
+    def _reconstruction_args(self) -> "tuple[Any, ...]":
+        return (self._field_name,)
+
 
 class NotNullFilter(StatementFilter):
     """Filter for IS NOT NULL queries.
@@ -779,6 +827,9 @@ class NotNullFilter(StatementFilter):
         """Return cache key for this filter configuration."""
         return ("NotNullFilter", self.field_name)
 
+    def _reconstruction_args(self) -> "tuple[Any, ...]":
+        return (self._field_name,)
+
 
 class NotInSearchFilter(SearchFilter):
     """Filter for negated text search queries.

{sqlspec-0.48.0 → sqlspec-0.48.1}/sqlspec/core/parameters/_types.py

@@ -73,6 +73,57 @@ Used when a function is known to return only named (not positional) parameters.
 This is narrower than :data:`ConvertedParameters` and excludes ``list``, ``tuple``, and ``None``.
 """
 
+TYPED_PARAMETER_SLOTS = ("_hash", "original_type", "semantic_name", "value")
+PARAMETER_INFO_SLOTS = ("name", "ordinal", "placeholder_text", "position", "style")
+PARAMETER_STYLE_CONFIG_SLOTS = (
+    "_hash_cache",
+    "allow_mixed_parameter_styles",
+    "ast_transformer",
+    "default_execution_parameter_style",
+    "default_parameter_style",
+    "has_native_list_expansion",
+    "json_deserializer",
+    "json_serializer",
+    "needs_static_script_compilation",
+    "output_transformer",
+    "preserve_original_params_for_many",
+    "preserve_parameter_format",
+    "strict_named_parameters",
+    "supported_execution_parameter_styles",
+    "supported_parameter_styles",
+    "type_coercion_map",
+)
+DRIVER_PARAMETER_PROFILE_SLOTS = (
+    "allow_mixed_parameter_styles",
+    "custom_type_coercions",
+    "default_ast_transformer",
+    "default_dialect",
+    "default_execution_style",
+    "default_output_transformer",
+    "default_style",
+    "extras",
+    "has_native_list_expansion",
+    "json_serializer_strategy",
+    "name",
+    "needs_static_script_compilation",
+    "preserve_original_params_for_many",
+    "preserve_parameter_format",
+    "statement_kwargs",
+    "strict_named_parameters",
+    "supported_execution_styles",
+    "supported_styles",
+)
+PARAMETER_PROFILE_SLOTS = ("_parameters", "_placeholder_counts", "named_parameters", "reused_ordinals", "styles")
+PARAMETER_PROCESSING_RESULT_SLOTS = (
+    "applied_wrap_types",
+    "input_named_parameters",
+    "parameter_profile",
+    "parameters",
+    "parsed_expression",
+    "sql",
+    "sqlglot_sql",
+)
+
 
 @mypyc_attr(allow_interpreted_subclasses=False)
 class ParameterStyle(str, Enum):
@@ -94,7 +145,7 @@ class ParameterStyle(str, Enum):
 class TypedParameter:
     """Wrapper that preserves original parameter type information."""
 
-    __slots__ = ("_hash", "original_type", "semantic_name", "value")
+    __slots__ = TYPED_PARAMETER_SLOTS
 
     def __init__(self, value: Any, original_type: "type | None" = None, semantic_name: "str | None" = None) -> None:
         self.value = value
@@ -121,6 +172,10 @@ class TypedParameter:
         name_part = f", semantic_name='{self.semantic_name}'" if self.semantic_name else ""
         return f"TypedParameter({self.value!r}, original_type={self.original_type.__name__}{name_part})"
 
+    def __reduce__(self) -> "tuple[Any, ...]":
+        """Reconstruct via ``TypedParameter(value, original_type, semantic_name)``."""
+        return (TypedParameter, (self.value, self.original_type, self.semantic_name))
+
 
 class _TupleAdapter:
     __slots__ = ("_as_list", "_serializer")
@@ -174,7 +229,7 @@ def _(value: bytes, semantic_name: "str | None" = None) -> "TypedParameter":
 class ParameterInfo:
     """Metadata describing a single detected SQL parameter."""
 
-    __slots__ = ("name", "ordinal", "placeholder_text", "position", "style")
+    __slots__ = PARAMETER_INFO_SLOTS
 
     def __init__(
         self, name: "str | None", style: "ParameterStyle", position: int, ordinal: int, placeholder_text: str
@@ -193,29 +248,16 @@ class ParameterInfo:
             ")"
         )
 
+    def __reduce__(self) -> "tuple[Any, ...]":
+        """Reconstruct via ``ParameterInfo(name, style, position, ordinal, placeholder_text)``."""
+        return (ParameterInfo, (self.name, self.style, self.position, self.ordinal, self.placeholder_text))
+
 
 @mypyc_attr(allow_interpreted_subclasses=False)
 class ParameterStyleConfig:
     """Configuration describing parameter behaviour for a statement."""
 
-    __slots__ = (
-        "_hash_cache",
-        "allow_mixed_parameter_styles",
-        "ast_transformer",
-        "default_execution_parameter_style",
-        "default_parameter_style",
-        "has_native_list_expansion",
-        "json_deserializer",
-        "json_serializer",
-        "needs_static_script_compilation",
-        "output_transformer",
-        "preserve_original_params_for_many",
-        "preserve_parameter_format",
-        "strict_named_parameters",
-        "supported_execution_parameter_styles",
-        "supported_parameter_styles",
-        "type_coercion_map",
-    )
+    __slots__ = PARAMETER_STYLE_CONFIG_SLOTS
 
     def __init__(
         self,
@@ -289,6 +331,33 @@ class ParameterStyleConfig:
 
         return hash(self)
 
+    def __reduce__(self) -> "tuple[Any, ...]":
+        """Reconstruct via the public ctor so copy/pickle work on mypyc native classes."""
+        return (
+            ParameterStyleConfig,
+            (
+                self.default_parameter_style,
+                tuple(self.supported_parameter_styles),
+                (
+                    tuple(self.supported_execution_parameter_styles)
+                    if self.supported_execution_parameter_styles is not None
+                    else None
+                ),
+                self.default_execution_parameter_style,
+                dict(self.type_coercion_map),
+                self.has_native_list_expansion,
+                self.needs_static_script_compilation,
+                self.allow_mixed_parameter_styles,
+                self.preserve_parameter_format,
+                self.preserve_original_params_for_many,
+                self.output_transformer,
+                self.ast_transformer,
+                self.json_serializer,
+                self.json_deserializer,
+                self.strict_named_parameters,
+            ),
+        )
+
     def replace(self, **overrides: Any) -> "ParameterStyleConfig":
         data: dict[str, Any] = {
             "default_parameter_style": self.default_parameter_style,
@@ -347,26 +416,7 @@ class ParameterStyleConfig:
 class DriverParameterProfile:
     """Immutable adapter profile describing parameter defaults."""
 
-    __slots__ = (
-        "allow_mixed_parameter_styles",
-        "custom_type_coercions",
-        "default_ast_transformer",
-        "default_dialect",
-        "default_execution_style",
-        "default_output_transformer",
-        "default_style",
-        "extras",
-        "has_native_list_expansion",
-        "json_serializer_strategy",
-        "name",
-        "needs_static_script_compilation",
-        "preserve_original_params_for_many",
-        "preserve_parameter_format",
-        "statement_kwargs",
-        "strict_named_parameters",
-        "supported_execution_styles",
-        "supported_styles",
-    )
+    __slots__ = DRIVER_PARAMETER_PROFILE_SLOTS
 
     def __init__(
         self,
@@ -412,12 +462,38 @@ class DriverParameterProfile:
         self.default_dialect = default_dialect
         self.statement_kwargs = MappingProxyType(dict(statement_kwargs)) if statement_kwargs else MappingProxyType({})
 
+    def __reduce__(self) -> "tuple[Any, ...]":
+        """Reconstruct via the public ctor so copy/pickle work on mypyc native classes."""
+        return (
+            DriverParameterProfile,
+            (
+                self.name,
+                self.default_style,
+                tuple(self.supported_styles),
+                self.default_execution_style,
+                tuple(self.supported_execution_styles) if self.supported_execution_styles is not None else None,
+                self.has_native_list_expansion,
+                self.preserve_parameter_format,
+                self.needs_static_script_compilation,
+                self.allow_mixed_parameter_styles,
+                self.preserve_original_params_for_many,
+                self.json_serializer_strategy,
+                dict(self.custom_type_coercions),
+                self.default_output_transformer,
+                self.default_ast_transformer,
+                dict(self.extras),
+                self.default_dialect,
+                dict(self.statement_kwargs),
+                self.strict_named_parameters,
+            ),
+        )
+
 
 @mypyc_attr(allow_interpreted_subclasses=False)
 class ParameterProfile:
     """Aggregate metadata describing detected parameters."""
 
-    __slots__ = ("_parameters", "_placeholder_counts", "named_parameters", "reused_ordinals", "styles")
+    __slots__ = PARAMETER_PROFILE_SLOTS
     named_parameters: tuple[str, ...]
     reused_ordinals: tuple[int, ...]
     styles: tuple[str, ...]
@@ -472,20 +548,16 @@ class ParameterProfile:
     def is_empty(self) -> bool:
         return not self._parameters
 
+    def __reduce__(self) -> "tuple[Any, ...]":
+        """Reconstruct via ``ParameterProfile(parameters)`` — fully rebuilds derived state."""
+        return (ParameterProfile, (self._parameters,))
+
 
 @mypyc_attr(allow_interpreted_subclasses=False)
 class ParameterProcessingResult:
     """Return container for parameter processing output."""
 
-    __slots__ = (
-        "applied_wrap_types",
-        "input_named_parameters",
-        "parameter_profile",
-        "parameters",
-        "parsed_expression",
-        "sql",
-        "sqlglot_sql",
-    )
+    __slots__ = PARAMETER_PROCESSING_RESULT_SLOTS
 
     def __init__(
         self,
@@ -520,6 +592,21 @@ class ParameterProcessingResult:
         msg = "ParameterProcessingResult exposes exactly two positional items"
         raise IndexError(msg)
 
+    def __reduce__(self) -> "tuple[Any, ...]":
+        """Reconstruct via the public ctor so copy/pickle work on mypyc native classes."""
+        return (
+            ParameterProcessingResult,
+            (
+                self.sql,
+                self.parameters,
+                self.parameter_profile,
+                self.sqlglot_sql,
+                self.parsed_expression,
+                self.input_named_parameters,
+                self.applied_wrap_types,
+            ),
+        )
+
 
 def is_iterable_parameters(obj: Any) -> bool:
     """Return True when the object behaves like an iterable parameter payload."""

{sqlspec-0.48.0 → sqlspec-0.48.1}/sqlspec/core/statement.py

@@ -122,6 +122,25 @@ PROCESSED_STATE_SLOTS: Final = (
     "is_many",
 )
 
+SQL_SLOTS: Final = (
+    "_compiled_from_cache",
+    "_dialect",
+    "_filters",
+    "_hash",
+    "_is_cache_direct",
+    "_is_many",
+    "_is_script",
+    "_named_parameters",
+    "_original_parameters",
+    "_pooled",
+    "_positional_parameters",
+    "_processed_state",
+    "_raw_expression",
+    "_raw_sql",
+    "_sql_param_counters",
+    "_statement_config",
+)
+
 
 @mypyc_attr(allow_interpreted_subclasses=False)
 class ProcessedState:
@@ -167,6 +186,27 @@ class ProcessedState:
     def __hash__(self) -> int:
         return hash((self.compiled_sql, str(self.execution_parameters), self.operation_type))
 
+    def __reduce__(self) -> "tuple[Any, ...]":
+        """Reconstruct via the public ctor so copy/pickle work on mypyc native classes."""
+        return (
+            ProcessedState,
+            (
+                self.compiled_sql,
+                self.execution_parameters,
+                self.parsed_expression,
+                self.operation_type,
+                self.input_named_parameters,
+                self.applied_wrap_types,
+                self.filter_hash,
+                self.parameter_fingerprint,
+                self.parameter_casts,
+                self.validation_errors,
+                self.parameter_profile,
+                self.operation_profile,
+                self.is_many,
+            ),
+        )
+
     def reset(self) -> None:
         """Reset processing state for reuse."""
         self.compiled_sql = ""
@@ -193,24 +233,7 @@ class SQL:
     and various execution modes including batch operations.
     """
 
-    __slots__ = (
-        "_compiled_from_cache",
-        "_dialect",
-        "_filters",
-        "_hash",
-        "_is_cache_direct",
-        "_is_many",
-        "_is_script",
-        "_named_parameters",
-        "_original_parameters",
-        "_pooled",
-        "_positional_parameters",
-        "_processed_state",
-        "_raw_expression",
-        "_raw_sql",
-        "_sql_param_counters",
-        "_statement_config",
-    )
+    __slots__ = SQL_SLOTS
 
     # Type annotation for mypyc compatibility
     _sql_param_counters: "dict[str, int]"
@@ -297,6 +320,21 @@ class SQL:
         """
         return get_default_config()
 
+    def __reduce__(self) -> "tuple[Any, ...]":
+        """Reconstruct via the public ctor with stored raw SQL, parameters, and filters."""
+        return (
+            _rebuild_sql,
+            (
+                self._raw_sql,
+                self._original_parameters,
+                tuple(self._filters),
+                self._statement_config,
+                self._is_many,
+                self._is_script,
+                dict(self._named_parameters),
+            ),
+        )
+
     def reset(self) -> None:
         """Reset SQL object for reuse in pooling scenarios."""
         if self._pooled and not self._compiled_from_cache and self._processed_state is not Empty:
@@ -1780,6 +1818,34 @@ class StatementConfig:
             ))
         return self._hash_cache
 
+    def __reduce__(self) -> "tuple[Any, ...]":
+        """Reconstruct via the public ctor so copy/pickle work on mypyc native classes."""
+        return (
+            StatementConfig,
+            (
+                self.parameter_config,
+                self.enable_parsing,
+                self.enable_validation,
+                self.enable_transformations,
+                self.enable_analysis,
+                self.enable_expression_simplification,
+                self.enable_column_pruning,
+                self.enable_parameter_type_wrapping,
+                self.enable_caching,
+                self.parameter_converter,
+                self.parameter_validator,
+                self.dialect,
+                self.execution_mode,
+                self.execution_args,
+                self.output_transformer,
+                self._user_statement_transformers,
+                self.enable_sqlcommenter,
+                self.sqlcommenter_attributes,
+                self.sqlcommenter_enable_traceparent,
+                self.sqlcommenter_enable_context,
+            ),
+        )
+
     def __repr__(self) -> str:
         """String representation of the StatementConfig instance."""
         field_strs = [
@@ -1862,4 +1928,24 @@ def get_default_parameter_config() -> ParameterStyleConfig:
     )
 
 
+def _rebuild_sql(
+    raw_sql: str,
+    original_parameters: "tuple[Any, ...]",
+    filters: "tuple[Any, ...]",
+    statement_config: "StatementConfig",
+    is_many: bool,
+    is_script: bool,
+    named_parameters: "dict[str, Any]",
+) -> "SQL":
+    """Reconstruct a SQL instance from pickled / deepcopied state."""
+    new_sql = SQL(raw_sql, *original_parameters, statement_config=statement_config, is_many=is_many)
+    if filters:
+        new_sql._filters.extend(filters)
+    if named_parameters:
+        new_sql._named_parameters.update(named_parameters)
+    if is_script:
+        new_sql._is_script = True
+    return new_sql
+
+
 Statement: TypeAlias = str | exp.Expr | SQL