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

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

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 [])