sqlspec 0.17.0__py3-none-any.whl → 0.18.0__py3-none-any.whl

sqlspec/core/result.py

@@ -6,12 +6,12 @@ including regular results and Apache Arrow format results.
 Components:
 - StatementResult: Abstract base class for SQL results
 - SQLResult: Main implementation for regular results
-- ArrowResult: Arrow-based results for high-performance data interchange
+- ArrowResult: Arrow-based results for data interchange
 
 Features:
 - Consistent interface across all result types
 - Support for both regular and Arrow format results
-- Comprehensive result metadata and statistics
+- Result metadata and statistics
 - Iterator support for result rows
 """
 
@@ -34,7 +34,7 @@ __all__ = ("ArrowResult", "SQLResult", "StatementResult")
 T = TypeVar("T")
 
 
-@mypyc_attr(allow_interpreted_subclasses=True)
+@mypyc_attr(allow_interpreted_subclasses=False)
 class StatementResult(ABC):
     """Base class for SQL statement execution results.
 
@@ -123,12 +123,10 @@ class StatementResult(ABC):
         Returns:
             The type of SQL operation that produced this result.
         """
-        if hasattr(self.statement, "operation_type"):
-            return cast("OperationType", self.statement.operation_type)
-        return "SELECT"
+        return self.statement.operation_type
 
 
-@mypyc_attr(allow_interpreted_subclasses=True)
+@mypyc_attr(allow_interpreted_subclasses=False)
 class SQLResult(StatementResult):
     """Result class for SQL operations that return rows or affect rows.
 
@@ -154,6 +152,8 @@ class SQLResult(StatementResult):
         "total_statements",
     )
 
+    _operation_type: OperationType
+
     def __init__(
         self,
         statement: "SQL",
@@ -189,7 +189,6 @@ class SQLResult(StatementResult):
         self.operation_index = operation_index
         self.parameters = parameters
 
-        # Optimize list initialization to avoid unnecessary object creation
         self.column_names = column_names or []
         self.total_count = total_count
         self.has_more = has_more
@@ -199,16 +198,15 @@ class SQLResult(StatementResult):
         self.total_statements = total_statements
         self.successful_statements = successful_statements
 
-        # Optimize column name extraction and count calculation
         if not self.column_names and data and len(data) > 0:
             self.column_names = list(data[0].keys())
         if self.total_count is None:
             self.total_count = len(data) if data is not None else 0
 
     @property
-    def operation_type(self) -> "OperationType":
+    def operation_type(self) -> OperationType:
         """Get operation type for this result."""
-        return cast("OperationType", self._operation_type)  # type: ignore[redundant-cast]
+        return self._operation_type
 
     def get_metadata(self, key: str, default: Any = None) -> Any:
         """Get metadata value by key.
@@ -261,7 +259,6 @@ class SQLResult(StatementResult):
         """
         op_type_upper = self.operation_type.upper()
         if op_type_upper == "SCRIPT":
-            # Cache calculation to avoid redundant work
             failed_statements = self.total_statements - self.successful_statements
             return [
                 {
@@ -478,26 +475,14 @@ class SQLResult(StatementResult):
         return next(iter(row.values()))
 
 
-@mypyc_attr(allow_interpreted_subclasses=True)
+@mypyc_attr(allow_interpreted_subclasses=False)
 class ArrowResult(StatementResult):
     """Result class for SQL operations that return Apache Arrow data.
 
     This class is used when database drivers support returning results as
-    Apache Arrow format for high-performance data interchange, especially
+    Apache Arrow format for data interchange, especially
     useful for analytics workloads and data science applications.
 
-    Performance Features:
-    - __slots__ optimization for memory efficiency
-    - Direct Arrow table access without intermediate copying
-    - Cached property evaluation for table metadata
-    - MyPyC compatibility for critical operations
-
-    Compatibility Features:
-    - Complete interface preservation with existing ArrowResult
-    - Same method signatures and behavior
-    - Same error handling and exceptions
-    - Identical Arrow table integration
-
     Args:
         statement: The original SQL statement that was executed.
         data: The Apache Arrow Table containing the result data.
@@ -516,7 +501,7 @@ class ArrowResult(StatementResult):
         metadata: Optional["dict[str, Any]"] = None,
         schema: Optional["dict[str, Any]"] = None,
     ) -> None:
-        """Initialize Arrow result with enhanced performance.
+        """Initialize Arrow result.
 
         Args:
             statement: The original SQL statement that was executed.

sqlspec/core/splitter.py

@@ -24,7 +24,7 @@ from abc import ABC, abstractmethod
 from collections.abc import Generator
 from enum import Enum
 from re import Pattern
-from typing import Any, Callable, Optional, Union
+from typing import Any, Callable, Final, Optional, Union, cast
 
 from mypy_extensions import mypyc_attr
 from typing_extensions import TypeAlias
@@ -45,11 +45,11 @@ __all__ = (
 
 logger = get_logger("sqlspec.core.splitter")
 
-DEFAULT_PATTERN_CACHE_SIZE = 1000  # Compiled regex patterns
-DEFAULT_RESULT_CACHE_SIZE = 5000  # Split results
-DEFAULT_CACHE_TTL = 3600  # 1 hour TTL
+DEFAULT_PATTERN_CACHE_SIZE: Final = 1000
+DEFAULT_RESULT_CACHE_SIZE: Final = 5000
+DEFAULT_CACHE_TTL: Final = 3600
 
-DIALECT_CONFIG_SLOTS = (
+DIALECT_CONFIG_SLOTS: Final = (
     "_block_starters",
     "_block_enders",
     "_statement_terminators",
@@ -59,9 +59,9 @@ DIALECT_CONFIG_SLOTS = (
     "_name",
 )
 
-TOKEN_SLOTS = ("type", "value", "line", "column", "position")
+TOKEN_SLOTS: Final = ("type", "value", "line", "column", "position")
 
-SPLITTER_SLOTS = (
+SPLITTER_SLOTS: Final = (
     "_dialect",
     "_strip_trailing_semicolon",
     "_token_patterns",
@@ -86,7 +86,7 @@ class TokenType(Enum):
     OTHER = "OTHER"
 
 
-@mypyc_attr(allow_interpreted_subclasses=True)
+@mypyc_attr(allow_interpreted_subclasses=False)
 class Token:
     """SQL token with metadata."""
 
@@ -108,7 +108,7 @@ TokenPattern: TypeAlias = Union[str, TokenHandler]
 CompiledTokenPattern: TypeAlias = Union[Pattern[str], TokenHandler]
 
 
-@mypyc_attr(allow_interpreted_subclasses=True)
+@mypyc_attr(allow_interpreted_subclasses=False)
 class DialectConfig(ABC):
     """Abstract base class for SQL dialect configurations."""
 
@@ -542,32 +542,28 @@ class BigQueryDialectConfig(DialectConfig):
         return self._statement_terminators
 
 
-_pattern_cache: Optional[UnifiedCache[list[tuple[TokenType, CompiledTokenPattern]]]] = None
-_result_cache: Optional[UnifiedCache[list[str]]] = None
+_pattern_cache: Optional[UnifiedCache] = None
+_result_cache: Optional[UnifiedCache] = None
 _cache_lock = threading.Lock()
 
 
-def _get_pattern_cache() -> UnifiedCache[list[tuple[TokenType, CompiledTokenPattern]]]:
+def _get_pattern_cache() -> UnifiedCache:
     """Get or create the pattern compilation cache."""
     global _pattern_cache
     if _pattern_cache is None:
         with _cache_lock:
             if _pattern_cache is None:
-                _pattern_cache = UnifiedCache[list[tuple[TokenType, CompiledTokenPattern]]](
-                    max_size=DEFAULT_PATTERN_CACHE_SIZE, ttl_seconds=DEFAULT_CACHE_TTL
-                )
+                _pattern_cache = UnifiedCache(max_size=DEFAULT_PATTERN_CACHE_SIZE, ttl_seconds=DEFAULT_CACHE_TTL)
     return _pattern_cache
 
 
-def _get_result_cache() -> UnifiedCache[list[str]]:
+def _get_result_cache() -> UnifiedCache:
     """Get or create the result cache."""
     global _result_cache
     if _result_cache is None:
         with _cache_lock:
             if _result_cache is None:
-                _result_cache = UnifiedCache[list[str]](
-                    max_size=DEFAULT_RESULT_CACHE_SIZE, ttl_seconds=DEFAULT_CACHE_TTL
-                )
+                _result_cache = UnifiedCache(max_size=DEFAULT_RESULT_CACHE_SIZE, ttl_seconds=DEFAULT_CACHE_TTL)
     return _result_cache
 
 
@@ -596,7 +592,7 @@ class StatementSplitter:
 
         cached_patterns = self._pattern_cache.get(cache_key)
         if cached_patterns is not None:
-            return cached_patterns
+            return cast("list[tuple[TokenType, CompiledTokenPattern]]", cached_patterns)
 
         compiled: list[tuple[TokenType, CompiledTokenPattern]] = []
         for token_type, pattern in self._token_patterns:
@@ -660,7 +656,7 @@ class StatementSplitter:
 
         cached_result = self._result_cache.get(cache_key)
         if cached_result is not None:
-            return cached_result
+            return cast("list[str]", cached_result)
 
         statements = self._do_split(sql)