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

sqlspec/adapters/sqlite/config.py

@@ -44,16 +44,18 @@ class SqliteConfig(SyncDatabaseConfig[SqliteConnection, SqliteConnectionPool, Sq
         *,
         pool_config: "Optional[Union[SqliteConnectionParams, dict[str, Any]]]" = None,
         pool_instance: "Optional[SqliteConnectionPool]" = None,
-        statement_config: "Optional[StatementConfig]" = None,
         migration_config: "Optional[dict[str, Any]]" = None,
+        statement_config: "Optional[StatementConfig]" = None,
+        driver_features: "Optional[dict[str, Any]]" = None,
     ) -> None:
         """Initialize SQLite configuration.
 
         Args:
             pool_config: Configuration parameters including connection settings
             pool_instance: Pre-created pool instance
-            statement_config: Default SQL statement configuration
             migration_config: Migration configuration
+            statement_config: Default SQL statement configuration
+            driver_features: Optional driver feature configuration
         """
         if pool_config is None:
             pool_config = {}
@@ -66,19 +68,19 @@ class SqliteConfig(SyncDatabaseConfig[SqliteConnection, SqliteConnectionPool, Sq
             pool_config=cast("dict[str, Any]", pool_config),
             migration_config=migration_config,
             statement_config=statement_config or sqlite_statement_config,
-            driver_features={},
+            driver_features=driver_features or {},
         )
 
     def _get_connection_config_dict(self) -> "dict[str, Any]":
         """Get connection configuration as plain dict for pool creation."""
-        # Filter out pool-specific parameters that SQLite doesn't use
+
         excluded_keys = {"pool_min_size", "pool_max_size", "pool_timeout", "pool_recycle_seconds", "extra"}
         return {k: v for k, v in self.pool_config.items() if v is not None and k not in excluded_keys}
 
     def _create_pool(self) -> SqliteConnectionPool:
         """Create connection pool from configuration."""
         config_dict = self._get_connection_config_dict()
-        # Pass all pool_config as kwargs to be ignored by the pool
+
         return SqliteConnectionPool(connection_parameters=config_dict, **self.pool_config)
 
     def _close_pool(self) -> None:

sqlspec/adapters/sqlite/driver.py

@@ -1,18 +1,4 @@
-"""Enhanced SQLite driver with CORE_ROUND_3 architecture integration.
-
-This driver implements the complete CORE_ROUND_3 architecture for:
-- 5-10x faster SQL compilation through single-pass processing
-- 40-60% memory reduction through __slots__ optimization
-- Enhanced caching for repeated statement execution
-- Complete backward compatibility with existing functionality
-
-Architecture Features:
-- Direct integration with sqlspec.core modules
-- Enhanced parameter processing with type coercion
-- Thread-safe unified caching system
-- MyPyC-optimized performance patterns
-- Zero-copy data access where possible
-"""
+"""SQLite driver implementation."""
 
 import contextlib
 import datetime
@@ -38,7 +24,6 @@ if TYPE_CHECKING:
 __all__ = ("SqliteCursor", "SqliteDriver", "SqliteExceptionHandler", "sqlite_statement_config")
 
 
-# Enhanced SQLite statement configuration using core modules with performance optimizations
 sqlite_statement_config = StatementConfig(
     dialect="sqlite",
     parameter_config=ParameterStyleConfig(
@@ -51,18 +36,12 @@ sqlite_statement_config = StatementConfig(
             datetime.datetime: lambda v: v.isoformat(),
             datetime.date: lambda v: v.isoformat(),
             Decimal: str,
-            # Note: Don't auto-convert dicts to JSON for SQLite
-            # This interferes with named parameter processing in execute_many
-            # dict: to_json,  # Removed to prevent parameter interference
             list: to_json,
-            # Note: Don't convert tuples to JSON for SQLite as they're used as parameter sets
-            # tuple: lambda v: to_json(list(v)),  # Removed - tuples are parameter sets
         },
         has_native_list_expansion=False,
         needs_static_script_compilation=False,
         preserve_parameter_format=True,
     ),
-    # Core processing features enabled for performance
     enable_parsing=True,
     enable_validation=True,
     enable_caching=True,
@@ -71,7 +50,7 @@ sqlite_statement_config = StatementConfig(
 
 
 class SqliteCursor:
-    """Context manager for SQLite cursor management with enhanced error handling."""
+    """Context manager for SQLite cursor management."""
 
     __slots__ = ("connection", "cursor")
 
@@ -84,14 +63,14 @@ class SqliteCursor:
         return self.cursor
 
     def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        _ = (exc_type, exc_val, exc_tb)  # Mark as intentionally unused
+        _ = (exc_type, exc_val, exc_tb)
         if self.cursor is not None:
             with contextlib.suppress(Exception):
                 self.cursor.close()
 
 
 class SqliteExceptionHandler:
-    """Custom sync context manager for handling SQLite database exceptions."""
+    """Context manager for handling SQLite database exceptions."""
 
     __slots__ = ()
 
@@ -135,27 +114,10 @@ class SqliteExceptionHandler:
 
 
 class SqliteDriver(SyncDriverAdapterBase):
-    """Enhanced SQLite driver with CORE_ROUND_3 architecture integration.
-
-    This driver leverages the complete core module system for maximum performance:
-
-    Performance Improvements:
-    - 5-10x faster SQL compilation through single-pass processing
-    - 40-60% memory reduction through __slots__ optimization
-    - Enhanced caching for repeated statement execution
-    - Zero-copy parameter processing where possible
-
-    Core Integration Features:
-    - sqlspec.core.statement for enhanced SQL processing
-    - sqlspec.core.parameters for optimized parameter handling
-    - sqlspec.core.cache for unified statement caching
-    - sqlspec.core.config for centralized configuration management
-
-    Compatibility:
-    - 100% backward compatibility with existing SQLite driver interface
-    - All existing tests pass without modification
-    - Complete StatementConfig API compatibility
-    - Preserved cursor management and exception handling patterns
+    """SQLite driver implementation.
+
+    Provides SQL statement execution, transaction management, and result handling
+    for SQLite databases using the standard sqlite3 module.
     """
 
     __slots__ = ()
@@ -167,21 +129,19 @@ class SqliteDriver(SyncDriverAdapterBase):
         statement_config: "Optional[StatementConfig]" = None,
         driver_features: "Optional[dict[str, Any]]" = None,
     ) -> None:
-        # Enhanced configuration with global settings integration
         if statement_config is None:
             cache_config = get_cache_config()
-            enhanced_config = sqlite_statement_config.replace(
+            statement_config = sqlite_statement_config.replace(
                 enable_caching=cache_config.compiled_cache_enabled,
-                enable_parsing=True,  # Default to enabled
-                enable_validation=True,  # Default to enabled
-                dialect="sqlite",  # Use adapter-specific dialect
+                enable_parsing=True,
+                enable_validation=True,
+                dialect="sqlite",
             )
-            statement_config = enhanced_config
 
         super().__init__(connection=connection, statement_config=statement_config, driver_features=driver_features)
 
     def with_cursor(self, connection: "SqliteConnection") -> "SqliteCursor":
-        """Create context manager for SQLite cursor with enhanced resource management."""
+        """Create context manager for SQLite cursor."""
         return SqliteCursor(connection)
 
     def handle_database_exceptions(self) -> "AbstractContextManager[None]":
@@ -191,9 +151,6 @@ class SqliteDriver(SyncDriverAdapterBase):
     def _try_special_handling(self, cursor: "sqlite3.Cursor", statement: "SQL") -> "Optional[SQLResult]":
         """Hook for SQLite-specific special operations.
 
-        SQLite doesn't have complex special operations like PostgreSQL COPY,
-        so this always returns None to proceed with standard execution.
-
         Args:
             cursor: SQLite cursor object
             statement: SQL statement to analyze
@@ -204,10 +161,14 @@ class SqliteDriver(SyncDriverAdapterBase):
         return None
 
     def _execute_script(self, cursor: "sqlite3.Cursor", statement: "SQL") -> "ExecutionResult":
-        """Execute SQL script using enhanced statement splitting and parameter handling.
+        """Execute SQL script with statement splitting and parameter handling.
 
-        Uses core module optimization for statement parsing and parameter processing.
-        Parameters are embedded as static values for script execution compatibility.
+        Args:
+            cursor: SQLite cursor object
+            statement: SQL statement containing multiple statements
+
+        Returns:
+            ExecutionResult with script execution details
         """
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
         statements = self.split_script_statements(sql, statement.statement_config, strip_trailing_semicolon=True)
@@ -224,34 +185,40 @@ class SqliteDriver(SyncDriverAdapterBase):
         )
 
     def _execute_many(self, cursor: "sqlite3.Cursor", statement: "SQL") -> "ExecutionResult":
-        """Execute SQL with multiple parameter sets using optimized batch processing.
+        """Execute SQL with multiple parameter sets.
+
+        Args:
+            cursor: SQLite cursor object
+            statement: SQL statement with multiple parameter sets
 
-        Leverages core parameter processing for enhanced type handling and validation.
+        Returns:
+            ExecutionResult with batch execution details
         """
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
 
-        # Enhanced parameter validation for executemany
         if not prepared_parameters:
             msg = "execute_many requires parameters"
             raise ValueError(msg)
 
-        # Ensure prepared_parameters is a list of parameter sets for SQLite executemany
         cursor.executemany(sql, prepared_parameters)
 
-        # Calculate affected rows more accurately
         affected_rows = cursor.rowcount if cursor.rowcount and cursor.rowcount > 0 else 0
 
         return self.create_execution_result(cursor, rowcount_override=affected_rows, is_many_result=True)
 
     def _execute_statement(self, cursor: "sqlite3.Cursor", statement: "SQL") -> "ExecutionResult":
-        """Execute single SQL statement with enhanced data handling and performance optimization.
+        """Execute single SQL statement.
 
-        Uses core processing for optimal parameter handling and result processing.
+        Args:
+            cursor: SQLite cursor object
+            statement: SQL statement to execute
+
+        Returns:
+            ExecutionResult with statement execution details
         """
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
         cursor.execute(sql, prepared_parameters or ())
 
-        # Enhanced SELECT result processing
         if statement.returns_rows():
             fetched_data = cursor.fetchall()
             column_names = [col[0] for col in cursor.description or []]
@@ -262,15 +229,12 @@ class SqliteDriver(SyncDriverAdapterBase):
                 cursor, selected_data=data, column_names=column_names, data_row_count=len(data), is_select_result=True
             )
 
-        # Enhanced non-SELECT result processing
         affected_rows = cursor.rowcount if cursor.rowcount and cursor.rowcount > 0 else 0
         return self.create_execution_result(cursor, rowcount_override=affected_rows)
 
-    # Transaction management with enhanced error handling
     def begin(self) -> None:
-        """Begin a database transaction with enhanced error handling."""
+        """Begin a database transaction."""
         try:
-            # Only begin if not already in a transaction
             if not self.connection.in_transaction:
                 self.connection.execute("BEGIN")
         except sqlite3.Error as e:
@@ -278,7 +242,7 @@ class SqliteDriver(SyncDriverAdapterBase):
             raise SQLSpecError(msg) from e
 
     def rollback(self) -> None:
-        """Rollback the current transaction with enhanced error handling."""
+        """Rollback the current transaction."""
         try:
             self.connection.rollback()
         except sqlite3.Error as e:
@@ -286,7 +250,7 @@ class SqliteDriver(SyncDriverAdapterBase):
             raise SQLSpecError(msg) from e
 
     def commit(self) -> None:
-        """Commit the current transaction with enhanced error handling."""
+        """Commit the current transaction."""
         try:
             self.connection.commit()
         except sqlite3.Error as e:

sqlspec/adapters/sqlite/pool.py

@@ -40,10 +40,7 @@ class SqliteConnectionPool:
     __slots__ = ("_connection_parameters", "_enable_optimizations", "_thread_local")
 
     def __init__(
-        self,
-        connection_parameters: "dict[str, Any]",
-        enable_optimizations: bool = True,
-        **kwargs: Any,  # Accept and ignore pool parameters for compatibility
+        self, connection_parameters: "dict[str, Any]", enable_optimizations: bool = True, **kwargs: Any
     ) -> None:
         """Initialize the thread-local connection manager.
 
@@ -60,18 +57,16 @@ class SqliteConnectionPool:
         """Create a new SQLite connection with optimizations."""
         connection = sqlite3.connect(**self._connection_parameters)
 
-        # Only apply optimizations if requested and not in-memory
         if self._enable_optimizations:
             database = self._connection_parameters.get("database", ":memory:")
             is_memory = database == ":memory:" or database.startswith("file::memory:")
 
             if not is_memory:
-                # WAL mode doesn't work with in-memory databases
                 connection.execute("PRAGMA journal_mode = WAL")
-                # Set busy timeout for better concurrent access
+
                 connection.execute("PRAGMA busy_timeout = 5000")
                 connection.execute("PRAGMA optimize")
-            # These work for all database types
+
             connection.execute("PRAGMA foreign_keys = ON")
             connection.execute("PRAGMA synchronous = NORMAL")
 
@@ -82,7 +77,6 @@ class SqliteConnectionPool:
         try:
             return cast("SqliteConnection", self._thread_local.connection)
         except AttributeError:
-            # Connection doesn't exist for this thread yet
             connection = self._create_connection()
             self._thread_local.connection = connection
             return connection
@@ -94,7 +88,6 @@ class SqliteConnectionPool:
             connection.close()
             del self._thread_local.connection
         except AttributeError:
-            # No connection for this thread
             pass
 
     @contextmanager
@@ -124,9 +117,7 @@ class SqliteConnectionPool:
         Args:
             connection: The connection to release (ignored)
         """
-        # No-op: thread-local connections are managed per-thread
 
-    # Compatibility methods that return dummy values
     def size(self) -> int:
         """Get pool size (always 1 for thread-local)."""
         try:

sqlspec/base.py

@@ -45,7 +45,6 @@ class SQLSpec:
 
     def __init__(self, *, loader: "Optional[SQLFileLoader]" = None) -> None:
         self._configs: dict[Any, DatabaseConfigProtocol[Any, Any, Any]] = {}
-        # Register sync cleanup only for sync resources
         atexit.register(self._cleanup_sync_pools)
         self._instance_cache_config: Optional[CacheConfig] = None
         self._sql_loader: Optional[SQLFileLoader] = loader
@@ -90,7 +89,6 @@ class SQLSpec:
                 except Exception as e:
                     logger.warning("Failed to prepare cleanup for config %s: %s", config_type.__name__, e)
 
-        # Close async pools concurrently
         if cleanup_tasks:
             try:
                 await asyncio.gather(*cleanup_tasks, return_exceptions=True)
@@ -98,9 +96,8 @@ class SQLSpec:
             except Exception as e:
                 logger.warning("Failed to complete async pool cleanup: %s", e)
 
-        # Close sync pools
         for _config_type, config in sync_configs:
-            config.close_pool()  # Let exceptions propagate for proper logging
+            config.close_pool()
 
         if sync_configs:
             logger.debug("Sync pool cleanup completed. Cleaned %d pools.", len(sync_configs))
@@ -596,12 +593,9 @@ class SQLSpec:
             )
         )
 
-    # SQL File Loading Integration
-
     def _ensure_sql_loader(self) -> "SQLFileLoader":
         """Ensure SQL loader is initialized lazily."""
         if self._sql_loader is None:
-            # Import here to avoid circular imports
             from sqlspec.loader import SQLFileLoader
 
             self._sql_loader = SQLFileLoader()
@@ -677,7 +671,6 @@ class SQLSpec:
         Note: This clears the cache and requires calling load_sql_files again.
         """
         if self._sql_loader is not None:
-            # Clear cache to force reload
             self._sql_loader.clear_cache()
             logger.debug("Cleared SQL cache for reload")
 

sqlspec/builder/__init__.py

@@ -1,6 +1,6 @@
 """SQL query builders for safe SQL construction.
 
-This package provides fluent interfaces for building SQL queries with automatic
+This package provides fluent interfaces for building SQL queries with
 parameter binding and validation.
 """
 

sqlspec/builder/_base.py

@@ -1,7 +1,7 @@
 """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.
+This module provides a fluent interface for building SQL queries with
+parameter binding and validation.
 """
 
 from abc import ABC, abstractmethod
@@ -47,7 +47,7 @@ class QueryBuilder(ABC):
     """Abstract base class for SQL query builders with SQLGlot optimization.
 
     Provides common functionality for dialect handling, parameter management,
-    query construction, and query optimization using SQLGlot.
+    and query construction using SQLGlot.
     """
 
     __slots__ = (
@@ -79,7 +79,6 @@ class QueryBuilder(ABC):
         self.optimize_predicates = optimize_predicates
         self.simplify_expressions = simplify_expressions
 
-        # Initialize mutable attributes
         self._expression: Optional[exp.Expression] = None
         self._parameters: dict[str, Any] = {}
         self._parameter_counter: int = 0
@@ -201,12 +200,11 @@ class QueryBuilder(ABC):
         if base_name not in self._parameters:
             return base_name
 
-        for i in range(1, 1000):  # Reasonable upper bound to prevent infinite loops
+        for i in range(1, 1000):
             name = f"{base_name}_{i}"
             if name not in self._parameters:
                 return name
 
-        # Fallback for edge case
         import uuid
 
         return f"{base_name}_{uuid.uuid4().hex[:8]}"
@@ -223,6 +221,10 @@ class QueryBuilder(ABC):
         import hashlib
 
         dialect_name: str = self.dialect_name or "default"
+
+        if self._expression is None:
+            self._expression = self._create_base_expression()
+
         expr_sql: str = self._expression.sql() if self._expression else "None"
 
         state_parts = [
@@ -336,7 +338,7 @@ class QueryBuilder(ABC):
         return SafeQuery(sql=sql_string, parameters=self._parameters.copy(), dialect=self.dialect)
 
     def _optimize_expression(self, expression: exp.Expression) -> exp.Expression:
-        """Apply SQLGlot optimizations to the expression with caching.
+        """Apply SQLGlot optimizations to the expression.
 
         Args:
             expression: The expression to optimize
@@ -377,7 +379,7 @@ class QueryBuilder(ABC):
             return optimized
 
     def to_statement(self, config: "Optional[StatementConfig]" = None) -> "SQL":
-        """Converts the built query into a SQL statement object with caching.
+        """Converts the built query into a SQL statement object.
 
         Args:
             config: Optional SQL configuration.
@@ -387,7 +389,7 @@ class QueryBuilder(ABC):
         """
         cache_config = get_cache_config()
         if not cache_config.compiled_cache_enabled:
-            return self._to_statement_without_cache(config)
+            return self._to_statement(config)
 
         cache_key_str = self._generate_builder_cache_key(config)
         cache_key = CacheKey((cache_key_str,))
@@ -397,13 +399,13 @@ class QueryBuilder(ABC):
         if cached_sql is not None:
             return cast("SQL", cached_sql)
 
-        sql_statement = self._to_statement_without_cache(config)
+        sql_statement = self._to_statement(config)
         unified_cache.put(cache_key, sql_statement)
 
         return sql_statement
 
-    def _to_statement_without_cache(self, config: "Optional[StatementConfig]" = None) -> "SQL":
-        """Internal method to create SQL statement without caching.
+    def _to_statement(self, config: "Optional[StatementConfig]" = None) -> "SQL":
+        """Internal method to create SQL statement.
 
         Args:
             config: Optional SQL configuration.
@@ -427,18 +429,30 @@ class QueryBuilder(ABC):
             )
 
         if config is None:
-            from sqlspec.core.statement import StatementConfig
-
-            parameter_config = ParameterStyleConfig(
-                default_parameter_style=ParameterStyle.QMARK, supported_parameter_styles={ParameterStyle.QMARK}
+            config = StatementConfig(
+                parameter_config=ParameterStyleConfig(
+                    default_parameter_style=ParameterStyle.QMARK, supported_parameter_styles={ParameterStyle.QMARK}
+                ),
+                dialect=safe_query.dialect,
             )
-            config = StatementConfig(parameter_config=parameter_config, dialect=safe_query.dialect)
+
+        sql_string = safe_query.sql
+        if (
+            config.dialect is not None
+            and config.dialect != safe_query.dialect
+            and self._expression is not None
+            and hasattr(self._expression, "sql")
+        ):
+            try:
+                sql_string = self._expression.sql(dialect=config.dialect, pretty=True)
+            except Exception:
+                sql_string = safe_query.sql
 
         if kwargs:
-            return SQL(safe_query.sql, statement_config=config, **kwargs)
+            return SQL(sql_string, statement_config=config, **kwargs)
         if parameters:
-            return SQL(safe_query.sql, *parameters, statement_config=config)
-        return SQL(safe_query.sql, statement_config=config)
+            return SQL(sql_string, *parameters, statement_config=config)
+        return SQL(sql_string, statement_config=config)
 
     def __str__(self) -> str:
         """Return the SQL string representation of the query.

sqlspec/builder/_column.py

@@ -5,7 +5,7 @@ for building SQL conditions with type safety and parameter binding.
 """
 
 from collections.abc import Iterable
-from typing import Any, Optional
+from typing import Any, Optional, cast
 
 from sqlglot import exp
 
@@ -241,6 +241,10 @@ class Column:
         """Create a DESC ordering expression."""
         return exp.Ordered(this=self._expression, desc=True)
 
+    def as_(self, alias: str) -> exp.Alias:
+        """Create an aliased expression."""
+        return cast("exp.Alias", exp.alias_(self._expression, alias))
+
     def __repr__(self) -> str:
         if self.table:
             return f"Column<{self.table}.{self.name}>"