sqlspec 0.17.1__py3-none-any.whl → 0.19.0__py3-none-any.whl

sqlspec/adapters/psqlpy/driver.py

@@ -1,18 +1,7 @@
-"""Enhanced Psqlpy 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
-- Psqlpy-optimized async resource management
-- MyPyC-optimized performance patterns
-- Zero-copy data access where possible
-- Native PostgreSQL parameter styles
+"""Psqlpy driver implementation.
+
+Provides PostgreSQL connectivity with parameter style conversion,
+type coercion, error handling, and transaction management.
 """
 
 import datetime
@@ -65,7 +54,7 @@ PSQLPY_STATUS_REGEX: Final[re.Pattern[str]] = re.compile(r"^([A-Z]+)(?:\s+(\d+))
 
 SPECIAL_TYPE_REGEX: Final[re.Pattern[str]] = re.compile(
     r"^(?:"
-    r"(?P<uuid>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9a-f]{32})|"
+    r"(?P<uuid>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})|"
     r"(?P<ipv4>(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(?:/(?:3[0-2]|[12]?[0-9]))?)|"
     r"(?P<ipv6>(?:(?:[0-9a-f]{1,4}:){7}[0-9a-f]{1,4}|(?:[0-9a-f]{1,4}:){1,7}:|:(?::[0-9a-f]{1,4}){1,7}|(?:[0-9a-f]{1,4}:){1,6}:[0-9a-f]{1,4}|::(?:ffff:)?(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))(?:/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9]))?)|"
     r"(?P<mac>(?:[0-9a-f]{2}[:-]){5}[0-9a-f]{2}|[0-9a-f]{12})|"
@@ -81,23 +70,13 @@ SPECIAL_TYPE_REGEX: Final[re.Pattern[str]] = re.compile(
 
 
 def _detect_postgresql_type(value: str) -> Optional[str]:
-    """Detect PostgreSQL data type from string value using enhanced regex.
-
-    The SPECIAL_TYPE_REGEX pattern matches the following PostgreSQL types:
-    - uuid: Standard UUID format (with dashes) or 32 hex characters (without dashes)
-    - ipv4: IPv4 addresses with optional CIDR notation (e.g., 192.168.1.1/24)
-    - ipv6: All IPv6 formats including compressed forms and IPv4-mapped addresses
-    - mac: MAC addresses in colon/dash separated or continuous format
-    - iso_datetime: ISO 8601 datetime strings with optional timezone
-    - iso_date: ISO 8601 date strings (YYYY-MM-DD)
-    - iso_time: Time strings with optional microseconds and timezone
-    - interval: PostgreSQL interval format or ISO 8601 duration format
-    - json: JSON objects ({...}) or arrays ([...])
-    - pg_array: PostgreSQL array literals ({...})
+    """Detect PostgreSQL data type from string value.
+
+    Detects common PostgreSQL types including UUID, IP addresses,
+    timestamps, JSON, and arrays.
 
     Returns:
-        Type name if detected ('uuid', 'ipv4', 'ipv6', 'mac', 'iso_datetime', etc.)
-        None if no special type detected
+        Type name if detected, None otherwise.
     """
     match = SPECIAL_TYPE_REGEX.match(value)
     if not match:
@@ -182,12 +161,9 @@ _PSQLPY_TYPE_CONVERTERS: dict[str, Any] = {
 
 
 def _convert_psqlpy_parameters(value: Any) -> Any:
-    """Convert parameters for Psqlpy compatibility using enhanced type detection.
+    """Convert parameters for Psqlpy compatibility.
 
-    This function performs intelligent type conversions based on detected PostgreSQL types.
-    Uses a hash map for O(1) type conversion dispatch. Works in conjunction with
-    the type_coercion_map for optimal performance - basic type coercion happens in
-    the core pipeline, while PostgreSQL-specific string type detection happens here.
+    Performs type conversions based on detected PostgreSQL types.
 
     Args:
         value: Parameter value to convert
@@ -212,7 +188,7 @@ def _convert_psqlpy_parameters(value: Any) -> Any:
 
 
 class PsqlpyCursor:
-    """Context manager for Psqlpy cursor management with enhanced error handling."""
+    """Context manager for Psqlpy cursor management."""
 
     __slots__ = ("_in_use", "connection")
 
@@ -221,12 +197,12 @@ class PsqlpyCursor:
         self._in_use = False
 
     async def __aenter__(self) -> "PsqlpyConnection":
-        """Enter cursor context with proper lifecycle tracking."""
+        """Enter cursor context."""
         self._in_use = True
         return self.connection
 
     async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        """Exit cursor context with proper cleanup."""
+        """Exit cursor context."""
         _ = (exc_type, exc_val, exc_tb)
         self._in_use = False
 
@@ -274,34 +250,10 @@ class PsqlpyExceptionHandler:
 
 
 class PsqlpyDriver(AsyncDriverAdapterBase):
-    """Enhanced Psqlpy 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
-    - Psqlpy-optimized async resource management
-
-    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
-
-    Psqlpy Features:
-    - Native PostgreSQL parameter styles (NUMERIC, NAMED_DOLLAR)
-    - Enhanced async execution with proper transaction management
-    - Optimized batch operations with psqlpy execute_many
-    - PostgreSQL-specific exception handling and command tag parsing
-
-    Compatibility:
-    - 100% backward compatibility with existing psqlpy driver interface
-    - All existing tests pass without modification
-    - Complete StatementConfig API compatibility
-    - Preserved async patterns and transaction management
+    """Psqlpy driver implementation.
+
+    Provides PostgreSQL connectivity through psqlpy with parameter style
+    conversion, type coercion, error handling, and transaction management.
     """
 
     __slots__ = ()
@@ -315,18 +267,17 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
     ) -> None:
         if statement_config is None:
             cache_config = get_cache_config()
-            enhanced_config = psqlpy_statement_config.replace(
+            statement_config = psqlpy_statement_config.replace(
                 enable_caching=cache_config.compiled_cache_enabled,
                 enable_parsing=True,
                 enable_validation=True,
                 dialect="postgres",
             )
-            statement_config = enhanced_config
 
         super().__init__(connection=connection, statement_config=statement_config, driver_features=driver_features)
 
     def with_cursor(self, connection: "PsqlpyConnection") -> "PsqlpyCursor":
-        """Create context manager for psqlpy cursor with enhanced resource management."""
+        """Create context manager for psqlpy cursor."""
         return PsqlpyCursor(connection)
 
     def handle_database_exceptions(self) -> "AbstractAsyncContextManager[None]":
@@ -336,30 +287,18 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
     async def _try_special_handling(self, cursor: "PsqlpyConnection", statement: SQL) -> "Optional[SQLResult]":
         """Hook for psqlpy-specific special operations.
 
-        Psqlpy has some specific optimizations we could leverage in the future:
-        - Native transaction management with connection pooling
-        - Batch execution optimization for scripts
-        - Cursor-based iteration for large result sets
-        - Connection pool management
-
-        For now, we proceed with standard execution but this provides
-        a clean extension point for psqlpy-specific optimizations.
-
         Args:
             cursor: Psqlpy connection object
             statement: SQL statement to analyze
 
         Returns:
-            None for standard execution (no special operations implemented yet)
+            None for standard execution
         """
         _ = (cursor, statement)
         return None
 
     async def _execute_script(self, cursor: "PsqlpyConnection", statement: SQL) -> "ExecutionResult":
-        """Execute SQL script using enhanced statement splitting and parameter handling.
-
-        Uses core module optimization for statement parsing and parameter processing.
-        Leverages psqlpy's execute_batch for optimal script execution when possible.
+        """Execute SQL script with statement splitting and parameter handling.
 
         Args:
             cursor: Psqlpy connection object
@@ -390,17 +329,14 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
         )
 
     async def _execute_many(self, cursor: "PsqlpyConnection", statement: SQL) -> "ExecutionResult":
-        """Execute SQL with multiple parameter sets using optimized batch processing.
-
-        Leverages psqlpy's execute_many for efficient batch operations with
-        enhanced parameter format handling for PostgreSQL.
+        """Execute SQL with multiple parameter sets using batch processing.
 
         Args:
             cursor: Psqlpy connection object
             statement: SQL statement with multiple parameter sets
 
         Returns:
-            ExecutionResult with accurate batch execution metadata
+            ExecutionResult with batch execution metadata
         """
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
 
@@ -422,17 +358,14 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
         return self.create_execution_result(cursor, rowcount_override=rows_affected, is_many_result=True)
 
     async def _execute_statement(self, cursor: "PsqlpyConnection", statement: SQL) -> "ExecutionResult":
-        """Execute single SQL statement with enhanced data handling and performance optimization.
-
-        Uses core processing for optimal parameter handling and result processing.
-        Leverages psqlpy's fetch for SELECT queries and execute for other operations.
+        """Execute single SQL statement with data handling.
 
         Args:
             cursor: Psqlpy connection object
             statement: SQL statement to execute
 
         Returns:
-            ExecutionResult with comprehensive execution metadata
+            ExecutionResult with execution metadata
         """
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
 
@@ -457,10 +390,7 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
         return self.create_execution_result(cursor, rowcount_override=rows_affected)
 
     def _extract_rows_affected(self, result: Any) -> int:
-        """Extract rows affected from psqlpy result using PostgreSQL command tag parsing.
-
-        Psqlpy may return command tag information that we can parse for accurate
-        row count reporting in INSERT/UPDATE/DELETE operations.
+        """Extract rows affected from psqlpy result.
 
         Args:
             result: Psqlpy execution result object
@@ -482,11 +412,6 @@ class PsqlpyDriver(AsyncDriverAdapterBase):
     def _parse_command_tag(self, tag: str) -> int:
         """Parse PostgreSQL command tag to extract rows affected.
 
-        PostgreSQL command tags have formats like:
-        - 'INSERT 0 1' (INSERT with 1 row)
-        - 'UPDATE 5' (UPDATE with 5 rows)
-        - 'DELETE 3' (DELETE with 3 rows)
-
         Args:
             tag: PostgreSQL command tag string
 

sqlspec/adapters/psycopg/config.py

@@ -85,17 +85,18 @@ class PsycopgSyncConfig(SyncDatabaseConfig[PsycopgSyncConnection, ConnectionPool
         *,
         pool_config: "Optional[Union[PsycopgPoolParams, dict[str, Any]]]" = None,
         pool_instance: Optional["ConnectionPool"] = 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 Psycopg synchronous configuration.
 
         Args:
             pool_config: Pool configuration parameters (TypedDict or dict)
             pool_instance: Existing pool instance to use
-            statement_config: Default SQL statement configuration
             migration_config: Migration configuration
-
+            statement_config: Default SQL statement configuration
+            driver_features: Optional driver feature configuration
         """
         processed_pool_config: dict[str, Any] = dict(pool_config) if pool_config else {}
         if "extra" in processed_pool_config:
@@ -107,6 +108,7 @@ class PsycopgSyncConfig(SyncDatabaseConfig[PsycopgSyncConnection, ConnectionPool
             pool_instance=pool_instance,
             migration_config=migration_config,
             statement_config=statement_config or psycopg_statement_config,
+            driver_features=driver_features or {},
         )
 
     def _create_pool(self) -> "ConnectionPool":
@@ -268,14 +270,16 @@ class PsycopgAsyncConfig(AsyncDatabaseConfig[PsycopgAsyncConnection, AsyncConnec
         pool_instance: "Optional[AsyncConnectionPool]" = None,
         migration_config: "Optional[dict[str, Any]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
+        driver_features: "Optional[dict[str, Any]]" = None,
     ) -> None:
         """Initialize Psycopg asynchronous configuration.
 
         Args:
             pool_config: Pool configuration parameters (TypedDict or dict)
             pool_instance: Existing pool instance to use
-            statement_config: Default SQL statement configuration
             migration_config: Migration configuration
+            statement_config: Default SQL statement configuration
+            driver_features: Optional driver feature configuration
         """
         processed_pool_config: dict[str, Any] = dict(pool_config) if pool_config else {}
         if "extra" in processed_pool_config:
@@ -287,6 +291,7 @@ class PsycopgAsyncConfig(AsyncDatabaseConfig[PsycopgAsyncConnection, AsyncConnec
             pool_instance=pool_instance,
             migration_config=migration_config,
             statement_config=statement_config or psycopg_statement_config,
+            driver_features=driver_features or {},
         )
 
     async def _create_pool(self) -> "AsyncConnectionPool":
@@ -306,7 +311,6 @@ class PsycopgAsyncConfig(AsyncDatabaseConfig[PsycopgAsyncConnection, AsyncConnec
             "num_workers": all_config.pop("num_workers", 3),
         }
 
-        # Capture autocommit setting before configuring the pool
         autocommit_setting = all_config.get("autocommit")
 
         async def configure_connection(conn: "PsycopgAsyncConnection") -> None: