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

sqlspec/adapters/duckdb/driver.py

@@ -12,12 +12,13 @@ from sqlspec.driver import SyncDriverAdapterProtocol
 from sqlspec.driver.connection import managed_transaction_sync
 from sqlspec.driver.mixins import (
     SQLTranslatorMixin,
+    SyncAdapterCacheMixin,
     SyncPipelinedExecutionMixin,
     SyncStorageMixin,
     ToSchemaMixin,
     TypeCoercionMixin,
 )
-from sqlspec.driver.parameters import normalize_parameter_sequence
+from sqlspec.driver.parameters import convert_parameter_sequence
 from sqlspec.statement.parameters import ParameterStyle
 from sqlspec.statement.result import ArrowResult, SQLResult
 from sqlspec.statement.sql import SQL, SQLConfig
@@ -38,6 +39,7 @@ logger = get_logger("adapters.duckdb")
 
 class DuckDBDriver(
     SyncDriverAdapterProtocol["DuckDBConnection", RowT],
+    SyncAdapterCacheMixin,
     SQLTranslatorMixin,
     TypeCoercionMixin,
     SyncStorageMixin,
@@ -63,7 +65,6 @@ class DuckDBDriver(
     supports_native_arrow_import: ClassVar[bool] = True
     supports_native_parquet_export: ClassVar[bool] = True
     supports_native_parquet_import: ClassVar[bool] = True
-    __slots__ = ()
 
     def __init__(
         self,
@@ -86,10 +87,10 @@ class DuckDBDriver(
         self, statement: SQL, connection: Optional["DuckDBConnection"] = None, **kwargs: Any
     ) -> SQLResult[RowT]:
         if statement.is_script:
-            sql, _ = statement.compile(placeholder_style=ParameterStyle.STATIC)
+            sql, _ = self._get_compiled_sql(statement, ParameterStyle.STATIC)
             return self._execute_script(sql, connection=connection, **kwargs)
 
-        sql, params = statement.compile(placeholder_style=self.default_parameter_style)
+        sql, params = self._get_compiled_sql(statement, self.default_parameter_style)
         params = self._process_parameters(params)
 
         if statement.is_many:
@@ -104,9 +105,9 @@ class DuckDBDriver(
         conn = connection if connection is not None else self._connection(None)
 
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn:
-            # Normalize parameters using consolidated utility
-            normalized_params = normalize_parameter_sequence(parameters)
-            final_params = normalized_params or []
+            # Convert parameters using consolidated utility
+            converted_params = convert_parameter_sequence(parameters)
+            final_params = converted_params or []
 
             if self.returns_rows(statement.expression):
                 result = txn_conn.execute(sql, final_params)
@@ -157,12 +158,12 @@ class DuckDBDriver(
 
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn:
             # Normalize parameter list using consolidated utility
-            normalized_param_list = normalize_parameter_sequence(param_list)
-            final_param_list = normalized_param_list or []
+            converted_param_list = convert_parameter_sequence(param_list)
+            final_param_list = converted_param_list or []
 
             # DuckDB throws an error if executemany is called with empty parameter list
             if not final_param_list:
-                return SQLResult(
+                return SQLResult(  # pyright: ignore
                     statement=SQL(sql, _dialect=self.dialect),
                     data=[],
                     rows_affected=0,
@@ -176,7 +177,7 @@ class DuckDBDriver(
                 # For executemany, fetchone() only returns the count from the last operation,
                 # so use parameter list length as the most accurate estimate
                 rows_affected = cursor.rowcount if cursor.rowcount >= 0 else len(final_param_list)
-                return SQLResult(
+                return SQLResult(  # pyright: ignore
                     statement=SQL(sql, _dialect=self.dialect),
                     data=[],
                     rows_affected=rows_affected,
@@ -191,20 +192,38 @@ class DuckDBDriver(
         conn = connection if connection is not None else self._connection(None)
 
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn:
+            # Split script into individual statements for validation
+            statements = self._split_script_statements(script)
+            suppress_warnings = kwargs.get("_suppress_warnings", False)
+
+            executed_count = 0
+            total_rows = 0
+
             with self._get_cursor(txn_conn) as cursor:
-                cursor.execute(script)
+                for statement in statements:
+                    if statement.strip():
+                        # Validate each statement unless warnings suppressed
+                        if not suppress_warnings:
+                            # Run validation through pipeline
+                            temp_sql = SQL(statement, config=self.config)
+                            temp_sql._ensure_processed()
+                            # Validation errors are logged as warnings by default
+
+                        cursor.execute(statement)
+                        executed_count += 1
+                        total_rows += cursor.rowcount or 0
 
             return SQLResult(
                 statement=SQL(script, _dialect=self.dialect).as_script(),
                 data=[],
-                rows_affected=0,
+                rows_affected=total_rows,
                 operation_type="SCRIPT",
                 metadata={
                     "status_message": "Script executed successfully.",
                     "description": "The script was sent to the database.",
                 },
-                total_statements=-1,
-                successful_statements=-1,
+                total_statements=executed_count,
+                successful_statements=executed_count,
             )
 
     # ============================================================================
@@ -214,7 +233,7 @@ class DuckDBDriver(
     def _fetch_arrow_table(self, sql: SQL, connection: "Optional[Any]" = None, **kwargs: Any) -> "ArrowResult":
         """Enhanced DuckDB native Arrow table fetching with streaming support."""
         conn = self._connection(connection)
-        sql_string, parameters = sql.compile(placeholder_style=self.default_parameter_style)
+        sql_string, parameters = self._get_compiled_sql(sql, self.default_parameter_style)
         parameters = self._process_parameters(parameters)
         result = conn.execute(sql_string, parameters or [])
 

sqlspec/adapters/oracledb/config.py

@@ -23,7 +23,6 @@ if TYPE_CHECKING:
 
     from oracledb import AuthMode
     from oracledb.pool import AsyncConnectionPool, ConnectionPool
-    from sqlglot.dialects.dialect import DialectType
 
 
 __all__ = ("CONNECTION_FIELDS", "POOL_FIELDS", "OracleAsyncConfig", "OracleSyncConfig")
@@ -73,43 +72,6 @@ POOL_FIELDS = CONNECTION_FIELDS.union(
 class OracleSyncConfig(SyncDatabaseConfig[OracleSyncConnection, "ConnectionPool", OracleSyncDriver]):
     """Configuration for Oracle synchronous database connections with direct field-based configuration."""
 
-    __slots__ = (
-        "_dialect",
-        "config_dir",
-        "default_row_type",
-        "dsn",
-        "edition",
-        "events",
-        "extras",
-        "getmode",
-        "homogeneous",
-        "host",
-        "increment",
-        "max",
-        "max_lifetime_session",
-        "max_sessions_per_shard",
-        "min",
-        "mode",
-        "password",
-        "ping_interval",
-        "pool_instance",
-        "port",
-        "retry_count",
-        "retry_delay",
-        "service_name",
-        "session_callback",
-        "sid",
-        "soda_metadata_cache",
-        "statement_config",
-        "tcp_connect_timeout",
-        "threaded",
-        "timeout",
-        "user",
-        "wait_timeout",
-        "wallet_location",
-        "wallet_password",
-    )
-
     is_async: ClassVar[bool] = False
     supports_connection_pooling: ClassVar[bool] = True
 
@@ -120,7 +82,7 @@ class OracleSyncConfig(SyncDatabaseConfig[OracleSyncConnection, "ConnectionPool"
     supported_parameter_styles: ClassVar[tuple[str, ...]] = ("named_colon", "positional_colon")
     """OracleDB supports :name (named_colon) and :1 (positional_colon) parameter styles."""
 
-    preferred_parameter_style: ClassVar[str] = "named_colon"
+    default_parameter_style: ClassVar[str] = "named_colon"
     """OracleDB's preferred parameter style is :name (named_colon)."""
 
     def __init__(
@@ -236,8 +198,6 @@ class OracleSyncConfig(SyncDatabaseConfig[OracleSyncConnection, "ConnectionPool"
         # Store other config
         self.statement_config = statement_config or SQLConfig()
         self.default_row_type = default_row_type
-        self.pool_instance = pool_instance
-        self._dialect: DialectType = None
 
         super().__init__()
 
@@ -300,7 +260,7 @@ class OracleSyncConfig(SyncDatabaseConfig[OracleSyncConnection, "ConnectionPool"
                 statement_config = replace(
                     statement_config,
                     allowed_parameter_styles=self.supported_parameter_styles,
-                    target_parameter_style=self.preferred_parameter_style,
+                    default_parameter_style=self.default_parameter_style,
                 )
             driver = self.driver_type(connection=conn, config=statement_config)
             yield driver
@@ -368,43 +328,6 @@ class OracleSyncConfig(SyncDatabaseConfig[OracleSyncConnection, "ConnectionPool"
 class OracleAsyncConfig(AsyncDatabaseConfig[OracleAsyncConnection, "AsyncConnectionPool", OracleAsyncDriver]):
     """Configuration for Oracle asynchronous database connections with direct field-based configuration."""
 
-    __slots__ = (
-        "_dialect",
-        "config_dir",
-        "default_row_type",
-        "dsn",
-        "edition",
-        "events",
-        "extras",
-        "getmode",
-        "homogeneous",
-        "host",
-        "increment",
-        "max",
-        "max_lifetime_session",
-        "max_sessions_per_shard",
-        "min",
-        "mode",
-        "password",
-        "ping_interval",
-        "pool_instance",
-        "port",
-        "retry_count",
-        "retry_delay",
-        "service_name",
-        "session_callback",
-        "sid",
-        "soda_metadata_cache",
-        "statement_config",
-        "tcp_connect_timeout",
-        "threaded",
-        "timeout",
-        "user",
-        "wait_timeout",
-        "wallet_location",
-        "wallet_password",
-    )
-
     is_async: ClassVar[bool] = True
     supports_connection_pooling: ClassVar[bool] = True
 
@@ -415,7 +338,7 @@ class OracleAsyncConfig(AsyncDatabaseConfig[OracleAsyncConnection, "AsyncConnect
     supported_parameter_styles: ClassVar[tuple[str, ...]] = ("named_colon", "positional_colon")
     """OracleDB supports :name (named_colon) and :1 (positional_colon) parameter styles."""
 
-    preferred_parameter_style: ClassVar[str] = "named_colon"
+    default_parameter_style: ClassVar[str] = "named_colon"
     """OracleDB's preferred parameter style is :name (named_colon)."""
 
     def __init__(
@@ -531,8 +454,6 @@ class OracleAsyncConfig(AsyncDatabaseConfig[OracleAsyncConnection, "AsyncConnect
         # Store other config
         self.statement_config = statement_config or SQLConfig()
         self.default_row_type = default_row_type
-        self.pool_instance: Optional[AsyncConnectionPool] = pool_instance
-        self._dialect: DialectType = None
 
         super().__init__()
 
@@ -623,7 +544,7 @@ class OracleAsyncConfig(AsyncDatabaseConfig[OracleAsyncConnection, "AsyncConnect
                 statement_config = replace(
                     statement_config,
                     allowed_parameter_styles=self.supported_parameter_styles,
-                    target_parameter_style=self.preferred_parameter_style,
+                    default_parameter_style=self.default_parameter_style,
                 )
             driver = self.driver_type(connection=conn, config=statement_config)
             yield driver

sqlspec/adapters/oracledb/driver.py

@@ -8,15 +8,17 @@ from sqlglot.dialects.dialect import DialectType
 from sqlspec.driver import AsyncDriverAdapterProtocol, SyncDriverAdapterProtocol
 from sqlspec.driver.connection import managed_transaction_async, managed_transaction_sync
 from sqlspec.driver.mixins import (
+    AsyncAdapterCacheMixin,
     AsyncPipelinedExecutionMixin,
     AsyncStorageMixin,
     SQLTranslatorMixin,
+    SyncAdapterCacheMixin,
     SyncPipelinedExecutionMixin,
     SyncStorageMixin,
     ToSchemaMixin,
     TypeCoercionMixin,
 )
-from sqlspec.driver.parameters import normalize_parameter_sequence
+from sqlspec.driver.parameters import convert_parameter_sequence
 from sqlspec.statement.parameters import ParameterStyle, ParameterValidator
 from sqlspec.statement.result import ArrowResult, SQLResult
 from sqlspec.statement.sql import SQL, SQLConfig
@@ -63,6 +65,7 @@ def _process_oracle_parameters(params: Any) -> Any:
 
 class OracleSyncDriver(
     SyncDriverAdapterProtocol[OracleSyncConnection, RowT],
+    SyncAdapterCacheMixin,
     SQLTranslatorMixin,
     TypeCoercionMixin,
     SyncStorageMixin,
@@ -78,7 +81,6 @@ class OracleSyncDriver(
     )
     default_parameter_style: ParameterStyle = ParameterStyle.NAMED_COLON
     support_native_arrow_export = True
-    __slots__ = ()
 
     def __init__(
         self,
@@ -109,7 +111,7 @@ class OracleSyncDriver(
         self, statement: SQL, connection: Optional[OracleSyncConnection] = None, **kwargs: Any
     ) -> SQLResult[RowT]:
         if statement.is_script:
-            sql, _ = statement.compile(placeholder_style=ParameterStyle.STATIC)
+            sql, _ = self._get_compiled_sql(statement, ParameterStyle.STATIC)
             return self._execute_script(sql, connection=connection, **kwargs)
 
         detected_styles = set()
@@ -132,11 +134,11 @@ class OracleSyncDriver(
                     break
 
         if statement.is_many:
-            sql, params = statement.compile(placeholder_style=target_style)
+            sql, params = self._get_compiled_sql(statement, target_style)
             params = self._process_parameters(params)
             return self._execute_many(sql, params, connection=connection, **kwargs)
 
-        sql, params = statement.compile(placeholder_style=target_style)
+        sql, params = self._get_compiled_sql(statement, target_style)
         return self._execute(sql, params, statement, connection=connection, **kwargs)
 
     def _execute(
@@ -191,19 +193,19 @@ class OracleSyncDriver(
 
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn:
             # Normalize parameter list using consolidated utility
-            normalized_param_list = normalize_parameter_sequence(param_list)
+            converted_param_list = convert_parameter_sequence(param_list)
 
             # Process parameters for Oracle
-            if normalized_param_list is None:
+            if converted_param_list is None:
                 processed_param_list = []
-            elif normalized_param_list and not isinstance(normalized_param_list, list):
+            elif converted_param_list and not isinstance(converted_param_list, list):
                 # Single parameter set, wrap it
-                processed_param_list = [normalized_param_list]
-            elif normalized_param_list and not isinstance(normalized_param_list[0], (list, tuple, dict)):
+                processed_param_list = [converted_param_list]
+            elif converted_param_list and not isinstance(converted_param_list[0], (list, tuple, dict)):
                 # Already a flat list, likely from incorrect usage
-                processed_param_list = [normalized_param_list]
+                processed_param_list = [converted_param_list]
             else:
-                processed_param_list = normalized_param_list
+                processed_param_list = converted_param_list
 
             # Parameters have already been processed in _execute_statement
             with self._get_cursor(txn_conn) as cursor:
@@ -224,19 +226,32 @@ class OracleSyncDriver(
 
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn:
             statements = self._split_script_statements(script, strip_trailing_semicolon=True)
+            suppress_warnings = kwargs.get("_suppress_warnings", False)
+            successful = 0
+            total_rows = 0
+
             with self._get_cursor(txn_conn) as cursor:
                 for statement in statements:
                     if statement and statement.strip():
+                        # Validate each statement unless warnings suppressed
+                        if not suppress_warnings:
+                            # Run validation through pipeline
+                            temp_sql = SQL(statement.strip(), config=self.config)
+                            temp_sql._ensure_processed()
+                            # Validation errors are logged as warnings by default
+
                         cursor.execute(statement.strip())
+                        successful += 1
+                        total_rows += cursor.rowcount or 0
 
             return SQLResult(
                 statement=SQL(script, _dialect=self.dialect).as_script(),
                 data=[],
-                rows_affected=0,
+                rows_affected=total_rows,
                 operation_type="SCRIPT",
                 metadata={"status_message": "SCRIPT EXECUTED"},
                 total_statements=len(statements),
-                successful_statements=len(statements),
+                successful_statements=successful,
             )
 
     def _fetch_arrow_table(self, sql: SQL, connection: "Optional[Any]" = None, **kwargs: Any) -> "ArrowResult":
@@ -306,6 +321,7 @@ class OracleSyncDriver(
 
 class OracleAsyncDriver(
     AsyncDriverAdapterProtocol[OracleAsyncConnection, RowT],
+    AsyncAdapterCacheMixin,
     SQLTranslatorMixin,
     TypeCoercionMixin,
     AsyncStorageMixin,
@@ -322,7 +338,6 @@ class OracleAsyncDriver(
     default_parameter_style: ParameterStyle = ParameterStyle.NAMED_COLON
     __supports_arrow__: ClassVar[bool] = True
     __supports_parquet__: ClassVar[bool] = False
-    __slots__ = ()
 
     def __init__(
         self,
@@ -355,7 +370,7 @@ class OracleAsyncDriver(
         self, statement: SQL, connection: Optional[OracleAsyncConnection] = None, **kwargs: Any
     ) -> SQLResult[RowT]:
         if statement.is_script:
-            sql, _ = statement.compile(placeholder_style=ParameterStyle.STATIC)
+            sql, _ = self._get_compiled_sql(statement, ParameterStyle.STATIC)
             return await self._execute_script(sql, connection=connection, **kwargs)
 
         detected_styles = set()
@@ -378,7 +393,7 @@ class OracleAsyncDriver(
                     break
 
         if statement.is_many:
-            sql, params = statement.compile(placeholder_style=target_style)
+            sql, params = self._get_compiled_sql(statement, target_style)
             params = self._process_parameters(params)
             # Oracle doesn't like underscores in bind parameter names
             if isinstance(params, list) and params and isinstance(params[0], dict):
@@ -392,7 +407,7 @@ class OracleAsyncDriver(
                                 param_set[new_key] = param_set.pop(key)
             return await self._execute_many(sql, params, connection=connection, **kwargs)
 
-        sql, params = statement.compile(placeholder_style=target_style)
+        sql, params = self._get_compiled_sql(statement, target_style)
         return await self._execute(sql, params, statement, connection=connection, **kwargs)
 
     async def _execute(
@@ -451,19 +466,19 @@ class OracleAsyncDriver(
 
         async with managed_transaction_async(conn, auto_commit=True) as txn_conn:
             # Normalize parameter list using consolidated utility
-            normalized_param_list = normalize_parameter_sequence(param_list)
+            converted_param_list = convert_parameter_sequence(param_list)
 
             # Process parameters for Oracle
-            if normalized_param_list is None:
+            if converted_param_list is None:
                 processed_param_list = []
-            elif normalized_param_list and not isinstance(normalized_param_list, list):
+            elif converted_param_list and not isinstance(converted_param_list, list):
                 # Single parameter set, wrap it
-                processed_param_list = [normalized_param_list]
-            elif normalized_param_list and not isinstance(normalized_param_list[0], (list, tuple, dict)):
+                processed_param_list = [converted_param_list]
+            elif converted_param_list and not isinstance(converted_param_list[0], (list, tuple, dict)):
                 # Already a flat list, likely from incorrect usage
-                processed_param_list = [normalized_param_list]
+                processed_param_list = [converted_param_list]
             else:
-                processed_param_list = normalized_param_list
+                processed_param_list = converted_param_list
 
             # Parameters have already been processed in _execute_statement
             async with self._get_cursor(txn_conn) as cursor:
@@ -486,20 +501,32 @@ class OracleAsyncDriver(
             # Oracle doesn't support multi-statement scripts in a single execute
             # The splitter now handles PL/SQL blocks correctly when strip_trailing_semicolon=True
             statements = self._split_script_statements(script, strip_trailing_semicolon=True)
+            suppress_warnings = kwargs.get("_suppress_warnings", False)
+            successful = 0
+            total_rows = 0
 
             async with self._get_cursor(txn_conn) as cursor:
                 for statement in statements:
                     if statement and statement.strip():
+                        # Validate each statement unless warnings suppressed
+                        if not suppress_warnings:
+                            # Run validation through pipeline
+                            temp_sql = SQL(statement.strip(), config=self.config)
+                            temp_sql._ensure_processed()
+                            # Validation errors are logged as warnings by default
+
                         await cursor.execute(statement.strip())
+                        successful += 1
+                        total_rows += cursor.rowcount or 0
 
             return SQLResult(
                 statement=SQL(script, _dialect=self.dialect).as_script(),
                 data=[],
-                rows_affected=0,
+                rows_affected=total_rows,
                 operation_type="SCRIPT",
                 metadata={"status_message": "SCRIPT EXECUTED"},
                 total_statements=len(statements),
-                successful_statements=len(statements),
+                successful_statements=successful,
             )
 
     async def _fetch_arrow_table(self, sql: SQL, connection: "Optional[Any]" = None, **kwargs: Any) -> "ArrowResult":

sqlspec/adapters/psqlpy/config.py

@@ -15,7 +15,6 @@ from sqlspec.typing import DictRow, Empty
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from sqlglot.dialects.dialect import DialectType
 
 logger = logging.getLogger("sqlspec.adapters.psqlpy")
 
@@ -69,56 +68,6 @@ __all__ = ("CONNECTION_FIELDS", "POOL_FIELDS", "PsqlpyConfig")
 class PsqlpyConfig(AsyncDatabaseConfig[PsqlpyConnection, ConnectionPool, PsqlpyDriver]):
     """Configuration for Psqlpy asynchronous database connections with direct field-based configuration."""
 
-    __slots__ = (
-        "_dialect",
-        "application_name",
-        "ca_file",
-        "channel_binding",
-        "client_encoding",
-        "configure",
-        "conn_recycling_method",
-        "connect_timeout_nanosec",
-        "connect_timeout_sec",
-        "db_name",
-        "default_row_type",
-        "dsn",
-        "extras",
-        "gssdelegation",
-        "gssencmode",
-        "gsslib",
-        "host",
-        "hosts",
-        "keepalives",
-        "keepalives_idle_nanosec",
-        "keepalives_idle_sec",
-        "keepalives_interval_nanosec",
-        "keepalives_interval_sec",
-        "keepalives_retries",
-        "krbsrvname",
-        "load_balance_hosts",
-        "max_db_pool_size",
-        "options",
-        "password",
-        "pool_instance",
-        "port",
-        "ports",
-        "require_auth",
-        "service",
-        "ssl_mode",
-        "sslcert",
-        "sslcompression",
-        "sslcrl",
-        "sslkey",
-        "sslnegotiation",
-        "sslpassword",
-        "sslrootcert",
-        "statement_config",
-        "target_session_attrs",
-        "tcp_user_timeout_nanosec",
-        "tcp_user_timeout_sec",
-        "username",
-    )
-
     is_async: ClassVar[bool] = True
     supports_connection_pooling: ClassVar[bool] = True
 
@@ -128,7 +77,7 @@ class PsqlpyConfig(AsyncDatabaseConfig[PsqlpyConnection, ConnectionPool, PsqlpyD
     supported_parameter_styles: ClassVar[tuple[str, ...]] = ("numeric",)
     """Psqlpy only supports $1, $2, ... (numeric) parameter style."""
 
-    preferred_parameter_style: ClassVar[str] = "numeric"
+    default_parameter_style: ClassVar[str] = "numeric"
     """Psqlpy's native parameter style is $1, $2, ... (numeric)."""
 
     def __init__(
@@ -283,8 +232,6 @@ class PsqlpyConfig(AsyncDatabaseConfig[PsqlpyConnection, ConnectionPool, PsqlpyD
         # Store other config
         self.statement_config = statement_config or SQLConfig()
         self.default_row_type = default_row_type
-        self.pool_instance: Optional[ConnectionPool] = pool_instance
-        self._dialect: DialectType = None
 
         super().__init__()
 
@@ -399,7 +346,7 @@ class PsqlpyConfig(AsyncDatabaseConfig[PsqlpyConnection, ConnectionPool, PsqlpyD
                 statement_config = replace(
                     statement_config,
                     allowed_parameter_styles=self.supported_parameter_styles,
-                    target_parameter_style=self.preferred_parameter_style,
+                    default_parameter_style=self.default_parameter_style,
                 )
             driver = self.driver_type(connection=conn, config=statement_config)
             yield driver

sqlspec/adapters/psqlpy/driver.py

@@ -9,6 +9,7 @@ from psqlpy import Connection
 from sqlspec.driver import AsyncDriverAdapterProtocol
 from sqlspec.driver.connection import managed_transaction_async
 from sqlspec.driver.mixins import (
+    AsyncAdapterCacheMixin,
     AsyncPipelinedExecutionMixin,
     AsyncStorageMixin,
     SQLTranslatorMixin,
@@ -31,6 +32,7 @@ logger = logging.getLogger("sqlspec")
 
 class PsqlpyDriver(
     AsyncDriverAdapterProtocol[PsqlpyConnection, RowT],
+    AsyncAdapterCacheMixin,
     SQLTranslatorMixin,
     TypeCoercionMixin,
     AsyncStorageMixin,
@@ -45,7 +47,6 @@ class PsqlpyDriver(
     dialect: "DialectType" = "postgres"
     supported_parameter_styles: "tuple[ParameterStyle, ...]" = (ParameterStyle.NUMERIC,)
     default_parameter_style: ParameterStyle = ParameterStyle.NUMERIC
-    __slots__ = ()
 
     def __init__(
         self,
@@ -79,7 +80,7 @@ class PsqlpyDriver(
         self, statement: SQL, connection: Optional[PsqlpyConnection] = None, **kwargs: Any
     ) -> SQLResult[RowT]:
         if statement.is_script:
-            sql, _ = statement.compile(placeholder_style=ParameterStyle.STATIC)
+            sql, _ = self._get_compiled_sql(statement, ParameterStyle.STATIC)
             return await self._execute_script(sql, connection=connection, **kwargs)
 
         # Detect parameter styles in the SQL
@@ -106,7 +107,7 @@ class PsqlpyDriver(
                     break
 
         # Compile with the determined style
-        sql, params = statement.compile(placeholder_style=target_style)
+        sql, params = self._get_compiled_sql(statement, target_style)
         params = self._process_parameters(params)
 
         if statement.is_many:
@@ -198,16 +199,35 @@ class PsqlpyDriver(
         conn = connection if connection is not None else self._connection(None)
 
         async with managed_transaction_async(conn, auto_commit=True) as txn_conn:
-            # psqlpy can execute multi-statement scripts directly
-            await txn_conn.execute(script)
+            # Split script into individual statements for validation
+            statements = self._split_script_statements(script)
+            suppress_warnings = kwargs.get("_suppress_warnings", False)
+
+            executed_count = 0
+            total_rows = 0
+
+            # Execute each statement individually for better control and validation
+            for statement in statements:
+                if statement.strip():
+                    # Validate each statement unless warnings suppressed
+                    if not suppress_warnings:
+                        # Run validation through pipeline
+                        temp_sql = SQL(statement, config=self.config)
+                        temp_sql._ensure_processed()
+                        # Validation errors are logged as warnings by default
+
+                    await txn_conn.execute(statement)
+                    executed_count += 1
+                    # psqlpy doesn't provide row count from execute()
+
             return SQLResult(
                 statement=SQL(script, _dialect=self.dialect).as_script(),
                 data=[],
-                rows_affected=0,
+                rows_affected=total_rows,
                 operation_type="SCRIPT",
                 metadata={"status_message": "SCRIPT EXECUTED"},
-                total_statements=-1,  # Not directly supported, but script is executed
-                successful_statements=-1,
+                total_statements=executed_count,
+                successful_statements=executed_count,
             )
 
     async def _ingest_arrow_table(self, table: "Any", table_name: str, mode: str = "append", **options: Any) -> int: