sqlspec 0.14.1__py3-none-any.whl → 0.16.0__py3-none-any.whl

sqlspec/driver/mixins/_type_coercion.py

@@ -1,128 +0,0 @@
-"""Type coercion mixin for database drivers.
-
-This module provides a mixin that all database drivers use to handle
-TypedParameter objects and perform appropriate type conversions.
-"""
-
-from decimal import Decimal
-from typing import TYPE_CHECKING, Any, Optional, Union
-
-from sqlspec.utils.type_guards import has_parameter_value
-
-if TYPE_CHECKING:
-    from sqlspec.typing import SQLParameterType
-
-__all__ = ("TypeCoercionMixin",)
-
-
-class TypeCoercionMixin:
-    """Mixin providing type coercion for database drivers.
-
-    This mixin is used by all database drivers to handle TypedParameter objects
-    and convert values to database-specific types.
-    """
-
-    def _process_parameters(self, parameters: "SQLParameterType") -> "SQLParameterType":
-        """Process parameters, extracting values from TypedParameter objects.
-
-        This method is called by drivers before executing SQL to handle
-        TypedParameter objects and perform necessary type conversions.
-
-        Args:
-            parameters: Raw parameters that may contain TypedParameter objects
-
-        Returns:
-            Processed parameters with TypedParameter values extracted and converted
-        """
-        if parameters is None:
-            return None
-
-        if isinstance(parameters, dict):
-            return self._process_dict_parameters(parameters)
-        if isinstance(parameters, (list, tuple)):
-            return self._process_sequence_parameters(parameters)
-        # Single scalar parameter
-        return self._coerce_parameter_type(parameters)
-
-    def _process_dict_parameters(self, params: dict[str, Any]) -> dict[str, Any]:
-        """Process dictionary parameters."""
-        result = {}
-        for key, value in params.items():
-            result[key] = self._coerce_parameter_type(value)
-        return result
-
-    def _process_sequence_parameters(self, params: Union[list, tuple]) -> Union[list, tuple]:
-        """Process list/tuple parameters."""
-        result = [self._coerce_parameter_type(p) for p in params]
-        return tuple(result) if isinstance(params, tuple) else result
-
-    def _coerce_parameter_type(self, param: Any) -> Any:
-        """Coerce a single parameter to the appropriate database type.
-
-        This method checks if the parameter is a TypedParameter and extracts
-        its value, then applies driver-specific type conversions.
-
-        Args:
-            param: Parameter value or TypedParameter object
-
-        Returns:
-            Coerced parameter value suitable for the database
-        """
-        if has_parameter_value(param):
-            value = param.value
-            type_hint = param.type_hint
-
-            return self._apply_type_coercion(value, type_hint)
-        # Regular parameter - apply default coercion
-        return self._apply_type_coercion(param, None)
-
-    def _apply_type_coercion(self, value: Any, type_hint: Optional[str]) -> Any:
-        """Apply driver-specific type coercion.
-
-        This method should be overridden by each driver to implement
-        database-specific type conversions.
-
-        Args:
-            value: The value to coerce
-            type_hint: Optional type hint from TypedParameter
-
-        Returns:
-            Coerced value
-        """
-        # Default implementation - override in specific drivers
-        # This base implementation handles common cases
-
-        if value is None:
-            return None
-
-        # Use type hint if available
-        if type_hint:
-            if type_hint == "boolean":
-                return self._coerce_boolean(value)
-            if type_hint == "decimal":
-                return self._coerce_decimal(value)
-            if type_hint == "json":
-                return self._coerce_json(value)
-            if type_hint.startswith("array"):
-                return self._coerce_array(value)
-
-        # Default: return value as-is
-        return value
-
-    def _coerce_boolean(self, value: Any) -> Any:
-        """Coerce boolean values. Override in drivers without native boolean support."""
-        return value
-
-    def _coerce_decimal(self, value: Any) -> Any:
-        """Coerce decimal values. Override for specific decimal handling."""
-        if isinstance(value, str):
-            return Decimal(value)
-        return value
-
-    def _coerce_json(self, value: Any) -> Any:
-        """Coerce JSON values. Override for databases needing JSON strings."""
-        return value
-
-    def _coerce_array(self, value: Any) -> Any:
-        """Coerce array values. Override for databases without native array support."""
-        return value

sqlspec/driver/parameters.py

@@ -1,138 +0,0 @@
-"""Consolidated parameter processing utilities for database drivers.
-
-This module provides centralized parameter handling logic to avoid duplication
-across sync and async driver implementations.
-"""
-
-from typing import TYPE_CHECKING, Any, Optional, Union
-
-from sqlspec.statement.filters import StatementFilter
-from sqlspec.utils.type_guards import is_sync_transaction_capable
-
-if TYPE_CHECKING:
-    from sqlspec.typing import StatementParameters
-
-__all__ = (
-    "convert_parameter_sequence",
-    "convert_parameters_to_positional",
-    "process_execute_many_parameters",
-    "separate_filters_and_parameters",
-    "should_use_transaction",
-)
-
-
-def separate_filters_and_parameters(
-    parameters: "tuple[Union[StatementParameters, StatementFilter], ...]",
-) -> "tuple[list[StatementFilter], list[Any]]":
-    """Separate filters from parameters in a mixed parameter tuple.
-
-    Args:
-        parameters: Mixed tuple of parameters and filters
-
-    Returns:
-        Tuple of (filters, parameters) lists
-    """
-
-    filters: list[StatementFilter] = []
-    param_values: list[Any] = []
-
-    for param in parameters:
-        if isinstance(param, StatementFilter):
-            filters.append(param)
-        else:
-            param_values.append(param)
-
-    return filters, param_values
-
-
-def process_execute_many_parameters(
-    parameters: "tuple[Union[StatementParameters, StatementFilter], ...]",
-) -> "tuple[list[StatementFilter], Optional[list[Any]]]":
-    """Process parameters for execute_many operations.
-
-    Args:
-        parameters: Mixed tuple of parameters and filters
-
-    Returns:
-        Tuple of (filters, parameter_sequence)
-    """
-    filters, param_values = separate_filters_and_parameters(parameters)
-
-    # Use first parameter as the sequence for execute_many
-    param_sequence = param_values[0] if param_values else None
-
-    # Normalize the parameter sequence
-    param_sequence = convert_parameter_sequence(param_sequence)
-
-    return filters, param_sequence
-
-
-def convert_parameter_sequence(params: Any) -> Optional[list[Any]]:
-    """Normalize a parameter sequence to a list format.
-
-    Args:
-        params: Parameter sequence in various formats
-
-    Returns:
-        converted list of parameters or None
-    """
-    if params is None:
-        return None
-
-    if isinstance(params, list):
-        return params
-
-    if isinstance(params, tuple):
-        return list(params)
-
-    # Check if it's iterable (but not string or dict)
-    # Use duck typing to check for iterable protocol
-    try:
-        iter(params)
-        if not isinstance(params, (str, dict)):
-            return list(params)
-    except TypeError:
-        pass
-
-    # Single parameter, wrap in list
-    return [params]
-
-
-def convert_parameters_to_positional(params: "dict[str, Any]", parameter_info: "list[Any]") -> list[Any]:
-    """Convert named parameters to positional based on SQL order.
-
-    Args:
-        params: Dictionary of named parameters
-        parameter_info: List of parameter info from SQL parsing
-
-    Returns:
-        List of positional parameters
-    """
-    if not params:
-        return []
-
-    # Handle param_0, param_1, etc. pattern
-    if all(key.startswith("param_") for key in params):
-        return [params[f"param_{i}"] for i in range(len(params))]
-
-    # Convert based on parameter info order
-    # Check for name attribute using getattr with default
-    result = []
-    for info in parameter_info:
-        param_name = getattr(info, "name", None)
-        if param_name is not None:
-            result.append(params.get(param_name, None))
-    return result
-
-
-def should_use_transaction(connection: Any, auto_commit: bool = True) -> bool:
-    """Determine if a transaction should be used.
-
-    Args:
-        connection: Database connection object
-        auto_commit: Whether auto-commit is enabled
-
-    Returns:
-        True if transaction capabilities are available and should be used
-    """
-    return False if auto_commit else is_sync_transaction_capable(connection)

sqlspec/statement/__init__.py

@@ -1,21 +0,0 @@
-"""SQL utilities, validation, and parameter handling."""
-
-from sqlspec.statement import builder, filters, parameters, result, sql
-from sqlspec.statement.filters import StatementFilter
-from sqlspec.statement.result import ArrowResult, SQLResult, StatementResult
-from sqlspec.statement.sql import SQL, SQLConfig, Statement
-
-__all__ = (
-    "SQL",
-    "ArrowResult",
-    "SQLConfig",
-    "SQLResult",
-    "Statement",
-    "StatementFilter",
-    "StatementResult",
-    "builder",
-    "filters",
-    "parameters",
-    "result",
-    "sql",
-)

sqlspec/statement/builder/_merge.py

@@ -1,95 +0,0 @@
-"""Safe SQL query builder with validation and parameter binding.
-
-This module provides a fluent interface for building SQL queries safely,
-with automatic parameter binding and validation.
-"""
-
-from dataclasses import dataclass
-
-from sqlglot import exp
-
-from sqlspec.statement.builder._base import QueryBuilder
-from sqlspec.statement.builder.mixins import (
-    MergeIntoClauseMixin,
-    MergeMatchedClauseMixin,
-    MergeNotMatchedBySourceClauseMixin,
-    MergeNotMatchedClauseMixin,
-    MergeOnClauseMixin,
-    MergeUsingClauseMixin,
-)
-from sqlspec.statement.result import SQLResult
-from sqlspec.typing import RowT
-
-__all__ = ("Merge",)
-
-
-@dataclass(unsafe_hash=True)
-class Merge(
-    QueryBuilder[RowT],
-    MergeUsingClauseMixin,
-    MergeOnClauseMixin,
-    MergeMatchedClauseMixin,
-    MergeNotMatchedClauseMixin,
-    MergeIntoClauseMixin,
-    MergeNotMatchedBySourceClauseMixin,
-):
-    """Builder for MERGE statements.
-
-    This builder provides a fluent interface for constructing SQL MERGE statements
-    (also known as UPSERT in some databases) with automatic parameter binding and validation.
-
-    Example:
-        ```python
-        # Basic MERGE statement
-        merge_query = (
-            Merge()
-            .into("target_table")
-            .using("source_table", "src")
-            .on("target_table.id = src.id")
-            .when_matched_then_update(
-                {"name": "src.name", "updated_at": "NOW()"}
-            )
-            .when_not_matched_then_insert(
-                columns=["id", "name", "created_at"],
-                values=["src.id", "src.name", "NOW()"],
-            )
-        )
-
-        # MERGE with subquery source
-        source_query = (
-            SelectBuilder()
-            .select("id", "name", "email")
-            .from_("temp_users")
-            .where("status = 'pending'")
-        )
-
-        merge_query = (
-            Merge()
-            .into("users")
-            .using(source_query, "src")
-            .on("users.email = src.email")
-            .when_matched_then_update({"name": "src.name"})
-            .when_not_matched_then_insert(
-                columns=["id", "name", "email"],
-                values=["src.id", "src.name", "src.email"],
-            )
-        )
-        ```
-    """
-
-    @property
-    def _expected_result_type(self) -> "type[SQLResult[RowT]]":
-        """Return the expected result type for this builder.
-
-        Returns:
-            The SQLResult type for MERGE statements.
-        """
-        return SQLResult[RowT]
-
-    def _create_base_expression(self) -> "exp.Merge":
-        """Create a base MERGE expression.
-
-        Returns:
-            A new sqlglot Merge expression with empty clauses.
-        """
-        return exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))

sqlspec/statement/cache.py

@@ -1,50 +0,0 @@
-"""Cache implementation for SQL statement processing."""
-
-import threading
-from collections import OrderedDict
-from typing import Any, Optional
-
-__all__ = ("SQLCache",)
-
-
-DEFAULT_CACHE_MAX_SIZE = 1000
-
-
-class SQLCache:
-    """A thread-safe LRU cache for processed SQL states."""
-
-    def __init__(self, max_size: int = DEFAULT_CACHE_MAX_SIZE) -> None:
-        self.cache: OrderedDict[str, Any] = OrderedDict()
-        self.max_size = max_size
-        self.lock = threading.Lock()
-
-    @property
-    def size(self) -> int:
-        """Get current cache size."""
-        return len(self.cache)
-
-    def get(self, key: str) -> Optional[Any]:
-        """Get an item from the cache, marking it as recently used."""
-        with self.lock:
-            if key in self.cache:
-                self.cache.move_to_end(key)
-                return self.cache[key]
-            return None
-
-    def set(self, key: str, value: Any) -> None:
-        """Set an item in the cache with LRU eviction."""
-        with self.lock:
-            if key in self.cache:
-                self.cache.move_to_end(key)
-            # Add new entry
-            elif len(self.cache) >= self.max_size:
-                self.cache.popitem(last=False)
-            self.cache[key] = value
-
-    def clear(self) -> None:
-        """Clear the cache."""
-        with self.lock:
-            self.cache.clear()
-
-
-sql_cache = SQLCache()