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

sqlspec/adapters/asyncmy/config.py

@@ -16,7 +16,6 @@ from sqlspec.typing import DictRow, Empty
 if TYPE_CHECKING:
     from asyncmy.cursors import Cursor, DictCursor
     from asyncmy.pool import Pool
-    from sqlglot.dialects.dialect import DialectType
 
 
 __all__ = ("CONNECTION_FIELDS", "POOL_FIELDS", "AsyncmyConfig")
@@ -50,34 +49,6 @@ POOL_FIELDS = CONNECTION_FIELDS.union({"minsize", "maxsize", "echo", "pool_recyc
 class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver]):  # pyright: ignore
     """Configuration for Asyncmy database connections with direct field-based configuration."""
 
-    __slots__ = (
-        "_dialect",
-        "autocommit",
-        "charset",
-        "connect_timeout",
-        "cursor_class",
-        "database",
-        "default_row_type",
-        "echo",
-        "extras",
-        "host",
-        "init_command",
-        "local_infile",
-        "maxsize",
-        "minsize",
-        "password",
-        "pool_instance",
-        "pool_recycle",
-        "port",
-        "read_default_file",
-        "read_default_group",
-        "sql_mode",
-        "ssl",
-        "statement_config",
-        "unix_socket",
-        "user",
-    )
-
     is_async: ClassVar[bool] = True
     supports_connection_pooling: ClassVar[bool] = True
     driver_type: type[AsyncmyDriver] = AsyncmyDriver
@@ -87,7 +58,7 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
     supported_parameter_styles: ClassVar[tuple[str, ...]] = ("pyformat_positional",)
     """AsyncMy only supports %s (pyformat_positional) parameter style."""
 
-    preferred_parameter_style: ClassVar[str] = "pyformat_positional"
+    default_parameter_style: ClassVar[str] = "pyformat_positional"
     """AsyncMy's native parameter style is %s (pyformat_positional)."""
 
     def __init__(
@@ -175,8 +146,6 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
         # Store other config
         self.statement_config = statement_config or SQLConfig()
         self.default_row_type = default_row_type
-        self.pool_instance: Optional[Pool] = pool_instance
-        self._dialect: DialectType = None
 
         super().__init__()  # pyright: ignore
 
@@ -271,7 +240,7 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
                 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,
                 )
             yield self.driver_type(connection=connection, config=statement_config)
 

sqlspec/adapters/asyncmy/driver.py

@@ -1,7 +1,7 @@
 import logging
 from collections.abc import AsyncGenerator, Sequence
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 from asyncmy import Connection
 from typing_extensions import TypeAlias
@@ -9,13 +9,14 @@ from typing_extensions import TypeAlias
 from sqlspec.driver import AsyncDriverAdapterProtocol
 from sqlspec.driver.connection import managed_transaction_async
 from sqlspec.driver.mixins import (
+    AsyncAdapterCacheMixin,
     AsyncPipelinedExecutionMixin,
     AsyncStorageMixin,
     SQLTranslatorMixin,
     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 SQLResult
 from sqlspec.statement.sql import SQL, SQLConfig
@@ -34,6 +35,7 @@ AsyncmyConnection: TypeAlias = Connection
 
 class AsyncmyDriver(
     AsyncDriverAdapterProtocol[AsyncmyConnection, RowT],
+    AsyncAdapterCacheMixin,
     SQLTranslatorMixin,
     TypeCoercionMixin,
     AsyncStorageMixin,
@@ -45,9 +47,6 @@ class AsyncmyDriver(
     dialect: "DialectType" = "mysql"
     supported_parameter_styles: "tuple[ParameterStyle, ...]" = (ParameterStyle.POSITIONAL_PYFORMAT,)
     default_parameter_style: ParameterStyle = ParameterStyle.POSITIONAL_PYFORMAT
-    __supports_arrow__: ClassVar[bool] = True
-    __supports_parquet__: ClassVar[bool] = False
-    __slots__ = ()
 
     def __init__(
         self,
@@ -72,7 +71,7 @@ class AsyncmyDriver(
         self, statement: SQL, connection: "Optional[AsyncmyConnection]" = 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
@@ -99,7 +98,7 @@ class AsyncmyDriver(
                     break
 
         # Compile with the determined style
-        sql, params = statement.compile(placeholder_style=target_style)
+        sql, params = self._get_compiled_sql(statement, target_style)
 
         if statement.is_many:
             params = self._process_parameters(params)
@@ -115,12 +114,10 @@ class AsyncmyDriver(
         conn = connection if connection is not None else self._connection(None)
 
         async with managed_transaction_async(conn, auto_commit=True) as txn_conn:
-            # Normalize parameters using consolidated utility
-            normalized_params = normalize_parameter_sequence(parameters)
+            # Convert parameters using consolidated utility
+            converted_params = convert_parameter_sequence(parameters)
             # AsyncMy doesn't like empty lists/tuples, convert to None
-            final_params = (
-                normalized_params[0] if normalized_params and len(normalized_params) == 1 else normalized_params
-            )
+            final_params = converted_params[0] if converted_params and len(converted_params) == 1 else converted_params
             if not final_params:
                 final_params = None
 
@@ -157,11 +154,11 @@ class AsyncmyDriver(
 
         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)
 
             params_list: list[Union[list[Any], tuple[Any, ...]]] = []
-            if normalized_param_list and isinstance(normalized_param_list, Sequence):
-                for param_set in normalized_param_list:
+            if converted_param_list and isinstance(converted_param_list, Sequence):
+                for param_set in converted_param_list:
                     if isinstance(param_set, (list, tuple)):
                         params_list.append(param_set)
                     elif param_set is None:
@@ -188,18 +185,28 @@ class AsyncmyDriver(
         async with managed_transaction_async(conn, auto_commit=True) as txn_conn:
             # AsyncMy may not support multi-statement scripts without CLIENT_MULTI_STATEMENTS flag
             statements = self._split_script_statements(script)
+            suppress_warnings = kwargs.get("_suppress_warnings", False)
             statements_executed = 0
+            total_rows = 0
 
             async with self._get_cursor(txn_conn) as cursor:
                 for statement_str in statements:
                     if statement_str:
+                        # Validate each statement unless warnings suppressed
+                        if not suppress_warnings:
+                            # Run validation through pipeline
+                            temp_sql = SQL(statement_str, config=self.config)
+                            temp_sql._ensure_processed()
+                            # Validation errors are logged as warnings by default
+
                         await cursor.execute(statement_str)
                         statements_executed += 1
+                        total_rows += cursor.rowcount if cursor.rowcount is not None else 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=statements_executed,

sqlspec/adapters/asyncpg/config.py

@@ -20,8 +20,6 @@ from sqlspec.utils.serializers import from_json, to_json
 if TYPE_CHECKING:
     from asyncio.events import AbstractEventLoop
 
-    from sqlglot.dialects.dialect import DialectType
-
 
 __all__ = ("CONNECTION_FIELDS", "POOL_FIELDS", "AsyncpgConfig")
 
@@ -108,44 +106,10 @@ POOL_FIELDS = CONNECTION_FIELDS.union(
 class AsyncpgConfig(AsyncDatabaseConfig[AsyncpgConnection, "Pool[Record]", AsyncpgDriver]):
     """Configuration for AsyncPG database connections using TypedDict."""
 
-    __slots__ = (
-        "_dialect",
-        "command_timeout",
-        "connect_timeout",
-        "connection_class",
-        "database",
-        "default_row_type",
-        "direct_tls",
-        "dsn",
-        "extras",
-        "host",
-        "init",
-        "json_deserializer",
-        "json_serializer",
-        "loop",
-        "max_cacheable_statement_size",
-        "max_cached_statement_lifetime",
-        "max_inactive_connection_lifetime",
-        "max_queries",
-        "max_size",
-        "min_size",
-        "passfile",
-        "password",
-        "pool_instance",
-        "port",
-        "record_class",
-        "server_settings",
-        "setup",
-        "ssl",
-        "statement_cache_size",
-        "statement_config",
-        "user",
-    )
-
     driver_type: type[AsyncpgDriver] = AsyncpgDriver
     connection_type: type[AsyncpgConnection] = type(AsyncpgConnection)  # type: ignore[assignment]
     supported_parameter_styles: ClassVar[tuple[str, ...]] = ("numeric",)
-    preferred_parameter_style: ClassVar[str] = "numeric"
+    default_parameter_style: ClassVar[str] = "numeric"
 
     def __init__(self, **kwargs: "Unpack[DriverParameters]") -> None:
         """Initialize AsyncPG configuration."""
@@ -220,10 +184,12 @@ class AsyncpgConfig(AsyncDatabaseConfig[AsyncpgConnection, "Pool[Record]", Async
         self.json_serializer = kwargs.get("json_serializer", to_json)
         self.json_deserializer = kwargs.get("json_deserializer", from_json)
         pool_instance_from_kwargs = kwargs.get("pool_instance")
-        self._dialect: DialectType = None
 
         super().__init__()
 
+        # Override prepared statements to True for PostgreSQL since it supports them well
+        self.enable_prepared_statements = kwargs.get("enable_prepared_statements", True)  # type: ignore[assignment]
+
         if pool_instance_from_kwargs is not None:
             self.pool_instance = pool_instance_from_kwargs
 
@@ -324,7 +290,7 @@ class AsyncpgConfig(AsyncDatabaseConfig[AsyncpgConnection, "Pool[Record]", Async
                 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,
                 )
             yield self.driver_type(connection=connection, config=statement_config)
 

sqlspec/adapters/asyncpg/driver.py

@@ -8,13 +8,14 @@ from typing_extensions import TypeAlias
 from sqlspec.driver import AsyncDriverAdapterProtocol
 from sqlspec.driver.connection import managed_transaction_async
 from sqlspec.driver.mixins import (
+    AsyncAdapterCacheMixin,
     AsyncPipelinedExecutionMixin,
     AsyncStorageMixin,
     SQLTranslatorMixin,
     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 SQLResult
 from sqlspec.statement.sql import SQL, SQLConfig
@@ -50,6 +51,7 @@ class AsyncpgDriver(
     TypeCoercionMixin,
     AsyncStorageMixin,
     AsyncPipelinedExecutionMixin,
+    AsyncAdapterCacheMixin,
     ToSchemaMixin,
 ):
     """AsyncPG PostgreSQL Driver Adapter. Modern protocol implementation."""
@@ -57,7 +59,6 @@ class AsyncpgDriver(
     dialect: "DialectType" = "postgres"
     supported_parameter_styles: "tuple[ParameterStyle, ...]" = (ParameterStyle.NUMERIC,)
     default_parameter_style: ParameterStyle = ParameterStyle.NUMERIC
-    __slots__ = ()
 
     def __init__(
         self,
@@ -91,7 +92,7 @@ class AsyncpgDriver(
         self, statement: SQL, connection: Optional[AsyncpgConnection] = 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()
@@ -112,10 +113,10 @@ class AsyncpgDriver(
                     break
 
         if statement.is_many:
-            sql, params = statement.compile(placeholder_style=target_style)
+            sql, params = self._get_compiled_sql(statement, target_style)
             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(
@@ -129,13 +130,13 @@ class AsyncpgDriver(
             return await self._execute_many(sql, parameters, connection=connection, **kwargs)
 
         async with managed_transaction_async(conn, auto_commit=True) as txn_conn:
-            # Normalize parameters using consolidated utility
-            normalized_params = normalize_parameter_sequence(parameters)
+            # Convert parameters using consolidated utility
+            converted_params = convert_parameter_sequence(parameters)
             # AsyncPG expects parameters as *args, not a single list
             args_for_driver: list[Any] = []
-            if normalized_params:
-                # normalized_params is already a list, just use it directly
-                args_for_driver = normalized_params
+            if converted_params:
+                # converted_params is already a list, just use it directly
+                args_for_driver = converted_params
 
             if self.returns_rows(statement.expression):
                 records = await txn_conn.fetch(sql, *args_for_driver)
@@ -174,12 +175,12 @@ class AsyncpgDriver(
 
         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)
 
             params_list: list[tuple[Any, ...]] = []
             rows_affected = 0
-            if normalized_param_list:
-                for param_set in normalized_param_list:
+            if converted_param_list:
+                for param_set in converted_param_list:
                     if isinstance(param_set, (list, tuple)):
                         params_list.append(tuple(param_set))
                     elif param_set is None:
@@ -205,17 +206,39 @@ class AsyncpgDriver(
     ) -> SQLResult[RowT]:
         # Use provided connection or driver's default connection
         conn = connection if connection is not None else self._connection(None)
+
         async with managed_transaction_async(conn, auto_commit=True) as txn_conn:
-            status = 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
+            last_status = None
+
+            # 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
+
+                    status = await txn_conn.execute(statement)
+                    executed_count += 1
+                    last_status = status
+                    # AsyncPG 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": status or "SCRIPT EXECUTED"},
-                total_statements=1,
-                successful_statements=1,
+                metadata={"status_message": last_status or "SCRIPT EXECUTED"},
+                total_statements=executed_count,
+                successful_statements=executed_count,
             )
 
     def _connection(self, connection: Optional[AsyncpgConnection] = None) -> AsyncpgConnection:

sqlspec/adapters/bigquery/config.py

@@ -19,7 +19,6 @@ if TYPE_CHECKING:
     from google.api_core.client_info import ClientInfo
     from google.api_core.client_options import ClientOptions
     from google.auth.credentials import Credentials
-    from sqlglot.dialects.dialect import DialectType
 
 logger = logging.getLogger(__name__)
 
@@ -76,45 +75,6 @@ class BigQueryConfig(NoPoolSyncConfig[BigQueryConnection, BigQueryDriver]):
     - Parquet and Arrow format optimization
     """
 
-    __slots__ = (
-        "_connection_instance",
-        "_dialect",
-        "client_info",
-        "client_options",
-        "credentials",
-        "credentials_path",
-        "dataframes_backend",
-        "dataset_id",
-        "default_load_job_config",
-        "default_query_job_config",
-        "default_row_type",
-        "edition",
-        "enable_bigquery_ml",
-        "enable_bigquery_omni",
-        "enable_column_level_security",
-        "enable_continuous_queries",
-        "enable_cross_cloud",
-        "enable_dataframes",
-        "enable_gemini_integration",
-        "enable_row_level_security",
-        "enable_vector_search",
-        "extras",
-        "job_timeout_ms",
-        "location",
-        "maximum_bytes_billed",
-        "on_connection_create",
-        "on_job_complete",
-        "on_job_start",
-        "parquet_enable_list_inference",
-        "pool_instance",
-        "project",
-        "query_timeout_ms",
-        "reservation_id",
-        "statement_config",
-        "use_avro_logical_types",
-        "use_query_cache",
-    )
-
     is_async: ClassVar[bool] = False
     supports_connection_pooling: ClassVar[bool] = False
 
@@ -125,7 +85,7 @@ class BigQueryConfig(NoPoolSyncConfig[BigQueryConnection, BigQueryDriver]):
     supported_parameter_styles: ClassVar[tuple[str, ...]] = ("named_at",)
     """BigQuery only supports @name (named_at) parameter style."""
 
-    preferred_parameter_style: ClassVar[str] = "named_at"
+    default_parameter_style: ClassVar[str] = "named_at"
     """BigQuery's native parameter style is @name (named_at)."""
 
     def __init__(
@@ -283,7 +243,6 @@ class BigQueryConfig(NoPoolSyncConfig[BigQueryConnection, BigQueryDriver]):
 
         # Store connection instance for reuse (BigQuery doesn't support traditional pooling)
         self._connection_instance: Optional[BigQueryConnection] = None
-        self._dialect: DialectType = None
 
         super().__init__()
 
@@ -391,7 +350,7 @@ class BigQueryConfig(NoPoolSyncConfig[BigQueryConnection, BigQueryDriver]):
                     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=connection,

sqlspec/adapters/bigquery/driver.py

@@ -24,12 +24,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.exceptions import SQLSpecError
 from sqlspec.statement.parameters import ParameterStyle, ParameterValidator
 from sqlspec.statement.result import ArrowResult, SQLResult
@@ -57,6 +58,7 @@ TIMESTAMP_ERROR_MSG_LENGTH = 189  # Length check for timestamp parsing error
 
 class BigQueryDriver(
     SyncDriverAdapterProtocol["BigQueryConnection", RowT],
+    SyncAdapterCacheMixin,
     SQLTranslatorMixin,
     TypeCoercionMixin,
     SyncStorageMixin,
@@ -71,8 +73,6 @@ class BigQueryDriver(
     - execute_script() - Multi-statement scripts and DDL operations
     """
 
-    __slots__ = ("_default_query_job_config", "on_job_complete", "on_job_start")
-
     dialect: "DialectType" = "bigquery"
     supported_parameter_styles: "tuple[ParameterStyle, ...]" = (ParameterStyle.NAMED_AT,)
     default_parameter_style: ParameterStyle = ParameterStyle.NAMED_AT
@@ -342,7 +342,7 @@ class BigQueryDriver(
         This is now just a pass-through since the core parameter generation
         has been fixed to generate BigQuery-compatible parameter names.
         """
-        return statement.compile(placeholder_style=target_style)
+        return self._get_compiled_sql(statement, target_style)
 
     def _execute_statement(
         self, statement: SQL, connection: Optional[BigQueryConnection] = None, **kwargs: Any
@@ -387,14 +387,14 @@ class BigQueryDriver(
         # BigQuery doesn't have traditional transactions, but we'll use the pattern for consistency
         # The managed_transaction_sync will just pass through for BigQuery Client objects
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn:
-            # Normalize parameters using consolidated utility
-            normalized_params = normalize_parameter_sequence(parameters)
+            # Convert parameters using consolidated utility
+            converted_params = convert_parameter_sequence(parameters)
             param_dict: dict[str, Any] = {}
-            if normalized_params:
-                if isinstance(normalized_params[0], dict):
-                    param_dict = normalized_params[0]
+            if converted_params:
+                if isinstance(converted_params[0], dict):
+                    param_dict = converted_params[0]
                 else:
-                    param_dict = {f"param_{i}": val for i, val in enumerate(normalized_params)}
+                    param_dict = {f"param_{i}": val for i, val in enumerate(converted_params)}
 
             bq_params = self._prepare_bq_query_parameters(param_dict)
 
@@ -413,14 +413,14 @@ class BigQueryDriver(
 
         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)
 
             # Use a multi-statement script for batch execution
             script_parts = []
             all_params: dict[str, Any] = {}
             param_counter = 0
 
-            for params in normalized_param_list or []:
+            for params in converted_param_list or []:
                 if isinstance(params, dict):
                     param_dict = params
                 elif isinstance(params, (list, tuple)):
@@ -470,20 +470,32 @@ class BigQueryDriver(
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn:
             # BigQuery does not support multi-statement scripts in a single job
             statements = self._split_script_statements(script)
+            suppress_warnings = kwargs.get("_suppress_warnings", False)
+            successful = 0
+            total_rows = 0
 
             for statement in statements:
                 if statement:
+                    # 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
+
                     query_job = self._run_query_job(statement, [], connection=txn_conn)
                     query_job.result(timeout=kwargs.get("bq_job_timeout"))
+                    successful += 1
+                    total_rows += query_job.num_dml_affected_rows 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 _connection(self, connection: "Optional[Client]" = None) -> "Client":

sqlspec/adapters/duckdb/config.py

@@ -16,8 +16,6 @@ if TYPE_CHECKING:
     from collections.abc import Generator, Sequence
     from contextlib import AbstractContextManager
 
-    from sqlglot.dialects.dialect import DialectType
-
 
 logger = logging.getLogger(__name__)
 
@@ -109,50 +107,6 @@ class DuckDBConfig(NoPoolSyncConfig[DuckDBConnection, DuckDBDriver]):
     - Performance optimizations for analytics workloads
     """
 
-    __slots__ = (
-        "_dialect",
-        "allow_community_extensions",
-        "allow_persistent_secrets",
-        "allow_unsigned_extensions",
-        "arrow_large_buffer_size",
-        "autoinstall_extension_repository",
-        "autoinstall_known_extensions",
-        "autoload_known_extensions",
-        "binary_as_string",
-        "checkpoint_threshold",
-        "config",
-        "custom_extension_repository",
-        "database",
-        "default_null_order",
-        "default_order",
-        "default_row_type",
-        "enable_external_access",
-        "enable_external_file_cache",
-        "enable_logging",
-        "enable_object_cache",
-        "enable_progress_bar",
-        "errors_as_json",
-        "extension_directory",
-        "extensions",
-        "extras",
-        "ieee_floating_point_ops",
-        "log_query_path",
-        "logging_level",
-        "max_temp_directory_size",
-        "memory_limit",
-        "on_connection_create",
-        "parquet_metadata_cache",
-        "pool_instance",
-        "preserve_insertion_order",
-        "progress_bar_time",
-        "read_only",
-        "secret_directory",
-        "secrets",
-        "statement_config",
-        "temp_directory",
-        "threads",
-    )
-
     is_async: ClassVar[bool] = False
     supports_connection_pooling: ClassVar[bool] = False
 
@@ -162,7 +116,7 @@ class DuckDBConfig(NoPoolSyncConfig[DuckDBConnection, DuckDBDriver]):
     supported_parameter_styles: ClassVar[tuple[str, ...]] = ("qmark", "numeric")
     """DuckDB supports ? (qmark) and $1, $2 (numeric) parameter styles."""
 
-    preferred_parameter_style: ClassVar[str] = "qmark"
+    default_parameter_style: ClassVar[str] = "qmark"
     """DuckDB's native parameter style is ? (qmark)."""
 
     def __init__(
@@ -325,7 +279,6 @@ class DuckDBConfig(NoPoolSyncConfig[DuckDBConnection, DuckDBDriver]):
         self.extensions = extensions or []
         self.secrets = secrets or []
         self.on_connection_create = on_connection_create
-        self._dialect: DialectType = None
 
         super().__init__()
 
@@ -479,7 +432,7 @@ class DuckDBConfig(NoPoolSyncConfig[DuckDBConnection, DuckDBDriver]):
                     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=connection, config=statement_config)
                 yield driver