sqlspec 0.12.2__py3-none-any.whl → 0.13.0__py3-none-any.whl

sqlspec/adapters/sqlite/config.py

@@ -3,7 +3,6 @@
 import logging
 import sqlite3
 from contextlib import contextmanager
-from dataclasses import replace
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union
 
 from sqlspec.adapters.sqlite.driver import SqliteConnection, SqliteDriver
@@ -88,7 +87,6 @@ class SqliteConfig(NoPoolSyncConfig[SqliteConnection, SqliteDriver]):
             uri: Whether to interpret database as URI
             **kwargs: Additional parameters (stored in extras)
         """
-        # Validate required parameters
         if database is None:
             msg = "database parameter cannot be None"
             raise TypeError(msg)
@@ -164,11 +162,13 @@ class SqliteConfig(NoPoolSyncConfig[SqliteConnection, SqliteDriver]):
         """
         with self.provide_connection(*args, **kwargs) as connection:
             statement_config = self.statement_config
+            # Inject parameter style info if not already set
             if statement_config.allowed_parameter_styles is None:
+                from dataclasses import replace
+
                 statement_config = replace(
                     statement_config,
                     allowed_parameter_styles=self.supported_parameter_styles,
                     target_parameter_style=self.preferred_parameter_style,
                 )
-
             yield self.driver_type(connection=connection, config=statement_config)

sqlspec/adapters/sqlite/driver.py

@@ -4,11 +4,12 @@ import sqlite3
 from collections.abc import Iterator
 from contextlib import contextmanager
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Optional, cast
 
 from typing_extensions import TypeAlias
 
 from sqlspec.driver import SyncDriverAdapterProtocol
+from sqlspec.driver.connection import managed_transaction_sync
 from sqlspec.driver.mixins import (
     SQLTranslatorMixin,
     SyncPipelinedExecutionMixin,
@@ -16,10 +17,11 @@ from sqlspec.driver.mixins import (
     ToSchemaMixin,
     TypeCoercionMixin,
 )
-from sqlspec.statement.parameters import ParameterStyle
-from sqlspec.statement.result import DMLResultDict, ScriptResultDict, SelectResultDict, SQLResult
+from sqlspec.driver.parameters import normalize_parameter_sequence
+from sqlspec.statement.parameters import ParameterStyle, ParameterValidator
+from sqlspec.statement.result import SQLResult
 from sqlspec.statement.sql import SQL, SQLConfig
-from sqlspec.typing import DictRow, ModelDTOT, RowT, is_dict_with_field
+from sqlspec.typing import DictRow, RowT
 from sqlspec.utils.logging import get_logger
 from sqlspec.utils.serializers import to_json
 
@@ -102,19 +104,22 @@ class SqliteDriver(
 
     def _execute_statement(
         self, statement: SQL, connection: Optional[SqliteConnection] = None, **kwargs: Any
-    ) -> Union[SelectResultDict, DMLResultDict, ScriptResultDict]:
+    ) -> SQLResult[RowT]:
         if statement.is_script:
             sql, _ = statement.compile(placeholder_style=ParameterStyle.STATIC)
-            return self._execute_script(sql, connection=connection, **kwargs)
+            return self._execute_script(sql, connection=connection, statement=statement, **kwargs)
+
+        detected_styles = set()
+        sql_str = statement.to_sql(placeholder_style=None)  # Get raw SQL
+        validator = self.config.parameter_validator if self.config else ParameterValidator()
+        param_infos = validator.extract_parameters(sql_str)
+        if param_infos:
+            detected_styles = {p.style for p in param_infos}
 
-        # Determine if we need to convert parameter style
-        detected_styles = {p.style for p in statement.parameter_info}
         target_style = self.default_parameter_style
 
-        # Check if any detected style is not supported
         unsupported_styles = detected_styles - set(self.supported_parameter_styles)
         if unsupported_styles:
-            # Convert to default style if we have unsupported styles
             target_style = self.default_parameter_style
         elif len(detected_styles) > 1:
             # Mixed styles detected - use default style for consistency
@@ -129,11 +134,10 @@ class SqliteDriver(
 
         if statement.is_many:
             sql, params = statement.compile(placeholder_style=target_style)
-            return self._execute_many(sql, params, connection=connection, **kwargs)
+            return self._execute_many(sql, params, connection=connection, statement=statement, **kwargs)
 
         sql, params = statement.compile(placeholder_style=target_style)
 
-        # Process parameters through type coercion
         params = self._process_parameters(params)
 
         # SQLite expects tuples for positional parameters
@@ -144,58 +148,105 @@ class SqliteDriver(
 
     def _execute(
         self, sql: str, parameters: Any, statement: SQL, connection: Optional[SqliteConnection] = None, **kwargs: Any
-    ) -> Union[SelectResultDict, DMLResultDict]:
+    ) -> SQLResult[RowT]:
         """Execute a single statement with parameters."""
-        conn = self._connection(connection)
-        with self._get_cursor(conn) as cursor:
-            # SQLite expects tuple or dict parameters
-            if parameters is not None and not isinstance(parameters, (tuple, list, dict)):
-                # Convert scalar to tuple
-                parameters = (parameters,)
-            cursor.execute(sql, parameters or ())
+        # Use provided connection or driver's default connection
+        conn = connection if connection is not None else self._connection(None)
+        with managed_transaction_sync(conn, auto_commit=True) as txn_conn, self._get_cursor(txn_conn) as cursor:
+            # Normalize parameters using consolidated utility
+            normalized_params_list = normalize_parameter_sequence(parameters)
+            params_for_execute: Any
+            if normalized_params_list and len(normalized_params_list) == 1:
+                # Single parameter should be tuple for SQLite
+                if not isinstance(normalized_params_list[0], (tuple, list, dict)):
+                    params_for_execute = (normalized_params_list[0],)
+                else:
+                    params_for_execute = normalized_params_list[0]
+            else:
+                # Multiple parameters
+                params_for_execute = tuple(normalized_params_list) if normalized_params_list else ()
+
+            cursor.execute(sql, params_for_execute)
             if self.returns_rows(statement.expression):
                 fetched_data: list[sqlite3.Row] = cursor.fetchall()
-                return {
-                    "data": fetched_data,
-                    "column_names": [col[0] for col in cursor.description or []],
-                    "rows_affected": len(fetched_data),
-                }
-            return {"rows_affected": cursor.rowcount, "status_message": "OK"}
+                return SQLResult(
+                    statement=statement,
+                    data=cast("list[RowT]", fetched_data),
+                    column_names=[col[0] for col in cursor.description or []],
+                    rows_affected=len(fetched_data),
+                    operation_type="SELECT",
+                )
+            operation_type = self._determine_operation_type(statement)
+
+            return SQLResult(
+                statement=statement,
+                data=[],
+                rows_affected=cursor.rowcount,
+                operation_type=operation_type,
+                metadata={"status_message": "OK"},
+            )
 
     def _execute_many(
-        self, sql: str, param_list: Any, connection: Optional[SqliteConnection] = None, **kwargs: Any
-    ) -> DMLResultDict:
+        self,
+        sql: str,
+        param_list: Any,
+        connection: Optional[SqliteConnection] = None,
+        statement: Optional[SQL] = None,
+        **kwargs: Any,
+    ) -> SQLResult[RowT]:
         """Execute a statement many times with a list of parameter tuples."""
-        conn = self._connection(connection)
-        if param_list:
-            param_list = self._process_parameters(param_list)
-
-        # Convert parameter list to proper format for executemany
-        formatted_params: list[tuple[Any, ...]] = []
-        if param_list and isinstance(param_list, list):
-            for param_set in cast("list[Union[list, tuple]]", param_list):
-                if isinstance(param_set, (list, tuple)):
-                    formatted_params.append(tuple(param_set))
-                elif param_set is None:
-                    formatted_params.append(())
-                else:
-                    formatted_params.append((param_set,))
-
-        with self._get_cursor(conn) as cursor:
-            cursor.executemany(sql, formatted_params)
-            return {"rows_affected": cursor.rowcount, "status_message": "OK"}
+        # Use provided connection or driver's default connection
+        conn = connection if connection is not None else self._connection(None)
+        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)
+            formatted_params: list[tuple[Any, ...]] = []
+            if normalized_param_list:
+                for param_set in normalized_param_list:
+                    if isinstance(param_set, (list, tuple)):
+                        formatted_params.append(tuple(param_set))
+                    elif param_set is None:
+                        formatted_params.append(())
+                    else:
+                        formatted_params.append((param_set,))
+
+            with self._get_cursor(txn_conn) as cursor:
+                cursor.executemany(sql, formatted_params)
+
+                if statement is None:
+                    statement = SQL(sql, _dialect=self.dialect)
+
+                return SQLResult(
+                    statement=statement,
+                    data=[],
+                    rows_affected=cursor.rowcount,
+                    operation_type="EXECUTE",
+                    metadata={"status_message": "OK"},
+                )
 
     def _execute_script(
-        self, script: str, connection: Optional[SqliteConnection] = None, **kwargs: Any
-    ) -> ScriptResultDict:
+        self, script: str, connection: Optional[SqliteConnection] = None, statement: Optional[SQL] = None, **kwargs: Any
+    ) -> SQLResult[RowT]:
         """Execute a script on the SQLite connection."""
-        conn = self._connection(connection)
+        # Use provided connection or driver's default connection
+        conn = connection if connection is not None else self._connection(None)
         with self._get_cursor(conn) as cursor:
             cursor.executescript(script)
-        # executescript doesn't auto-commit in some cases
+        # executescript doesn't auto-commit in some cases - force commit
         conn.commit()
-        result: ScriptResultDict = {"statements_executed": -1, "status_message": "SCRIPT EXECUTED"}
-        return result
+
+        if statement is None:
+            statement = SQL(script, _dialect=self.dialect).as_script()
+
+        return SQLResult(
+            statement=statement,
+            data=[],
+            rows_affected=-1,  # Unknown for scripts
+            operation_type="SCRIPT",
+            total_statements=-1,  # SQLite doesn't provide this info
+            successful_statements=-1,
+            metadata={"status_message": "SCRIPT EXECUTED"},
+        )
 
     def _ingest_arrow_table(self, table: Any, table_name: str, mode: str = "create", **options: Any) -> int:
         """SQLite-specific Arrow table ingestion using CSV conversion.
@@ -208,12 +259,10 @@ class SqliteDriver(
 
         import pyarrow.csv as pa_csv
 
-        # Convert Arrow table to CSV in memory
         csv_buffer = io.BytesIO()
         pa_csv.write_csv(table, csv_buffer)
         csv_content = csv_buffer.getvalue()
 
-        # Create a temporary file path
         temp_filename = f"sqlspec_temp_{table_name}_{id(self)}.csv"
         temp_path = Path(tempfile.gettempdir()) / temp_filename
 
@@ -258,46 +307,3 @@ class SqliteDriver(
             data_iter = list(reader)  # Read all data into memory
             cursor.executemany(sql, data_iter)
             return cursor.rowcount
-
-    def _wrap_select_result(
-        self, statement: SQL, result: SelectResultDict, schema_type: Optional[type[ModelDTOT]] = None, **kwargs: Any
-    ) -> Union[SQLResult[ModelDTOT], SQLResult[RowT]]:
-        rows_as_dicts = [dict(row) for row in result["data"]]
-        if schema_type:
-            return SQLResult[ModelDTOT](
-                statement=statement,
-                data=list(self.to_schema(data=rows_as_dicts, schema_type=schema_type)),
-                column_names=result["column_names"],
-                rows_affected=result["rows_affected"],
-                operation_type="SELECT",
-            )
-
-        return SQLResult[RowT](
-            statement=statement,
-            data=rows_as_dicts,
-            column_names=result["column_names"],
-            rows_affected=result["rows_affected"],
-            operation_type="SELECT",
-        )
-
-    def _wrap_execute_result(
-        self, statement: SQL, result: Union[DMLResultDict, ScriptResultDict], **kwargs: Any
-    ) -> SQLResult[RowT]:
-        if is_dict_with_field(result, "statements_executed"):
-            return SQLResult[RowT](
-                statement=statement,
-                data=[],
-                rows_affected=0,
-                operation_type="SCRIPT",
-                metadata={
-                    "status_message": result.get("status_message", ""),
-                    "statements_executed": result.get("statements_executed", -1),
-                },
-            )
-        return SQLResult[RowT](
-            statement=statement,
-            data=[],
-            rows_affected=cast("int", result.get("rows_affected", -1)),
-            operation_type=statement.expression.key.upper() if statement.expression else "UNKNOWN",
-            metadata={"status_message": result.get("status_message", "")},
-        )

sqlspec/config.py

@@ -97,7 +97,6 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
         Returns:
             The SQL dialect type.
         """
-        # Get dialect from driver_class (all drivers must have a dialect attribute)
         return self.driver_type.dialect
 
     @abstractmethod
@@ -154,17 +153,14 @@ class DatabaseConfigProtocol(ABC, Generic[ConnectionT, PoolT, DriverT]):
         """
         namespace: dict[str, type[Any]] = {}
 
-        # Add the driver and config types
         if hasattr(self, "driver_type") and self.driver_type:
             namespace[self.driver_type.__name__] = self.driver_type
 
         namespace[self.__class__.__name__] = self.__class__
 
-        # Add connection type(s)
         if hasattr(self, "connection_type") and self.connection_type:
             connection_type = self.connection_type
 
-            # Handle Union types (like AsyncPG's Union[Connection, PoolConnectionProxy])
             if hasattr(connection_type, "__args__"):
                 # It's a generic type, extract the actual types
                 for arg_type in connection_type.__args__:  # type: ignore[attr-defined]

sqlspec/driver/_async.py

@@ -1,17 +1,22 @@
 """Asynchronous driver protocol implementation."""
 
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Optional, Union, cast, overload
+from dataclasses import replace
+from typing import TYPE_CHECKING, Any, Optional, Union, overload
 
 from sqlspec.driver._common import CommonDriverAttributesMixin
-from sqlspec.statement.builder import DeleteBuilder, InsertBuilder, QueryBuilder, SelectBuilder, UpdateBuilder
-from sqlspec.statement.filters import StatementFilter
+from sqlspec.driver.parameters import process_execute_many_parameters
+from sqlspec.statement.builder import Delete, Insert, QueryBuilder, Select, Update
 from sqlspec.statement.result import SQLResult
 from sqlspec.statement.sql import SQL, SQLConfig, Statement
 from sqlspec.typing import ConnectionT, DictRow, ModelDTOT, RowT, StatementParameters
+from sqlspec.utils.logging import get_logger
+from sqlspec.utils.type_guards import can_convert_to_schema
 
 if TYPE_CHECKING:
-    from sqlspec.statement.result import DMLResultDict, ScriptResultDict, SelectResultDict
+    from sqlspec.statement.filters import StatementFilter
+
+logger = get_logger("sqlspec")
 
 __all__ = ("AsyncDriverAdapterProtocol",)
 
@@ -49,42 +54,64 @@ class AsyncDriverAdapterProtocol(CommonDriverAttributesMixin[ConnectionT, RowT],
 
         if isinstance(statement, QueryBuilder):
             return statement.to_statement(config=_config)
-        # If statement is already a SQL object, return it as-is
+        # If statement is already a SQL object, handle additional parameters
         if isinstance(statement, SQL):
+            if parameters or kwargs:
+                new_config = _config
+                if self.dialect and not new_config.dialect:
+                    new_config = replace(new_config, dialect=self.dialect)
+                # Use raw SQL if available to ensure proper parsing with dialect
+                sql_source = statement._raw_sql or statement._statement
+                # Preserve filters and state when creating new SQL object
+                existing_state = {
+                    "is_many": statement._is_many,
+                    "is_script": statement._is_script,
+                    "original_parameters": statement._original_parameters,
+                    "filters": statement._filters,
+                    "positional_params": statement._positional_params,
+                    "named_params": statement._named_params,
+                }
+                return SQL(sql_source, *parameters, config=new_config, _existing_state=existing_state, **kwargs)
+            # Even without additional parameters, ensure dialect is set
+            if self.dialect and (not statement._config.dialect or statement._config.dialect != self.dialect):
+                new_config = replace(statement._config, dialect=self.dialect)
+                # Use raw SQL if available to ensure proper parsing with dialect
+                sql_source = statement._raw_sql or statement._statement
+                # Preserve parameters and state when creating new SQL object
+                # Use the public parameters property which always has the right value
+                existing_state = {
+                    "is_many": statement._is_many,
+                    "is_script": statement._is_script,
+                    "original_parameters": statement._original_parameters,
+                    "filters": statement._filters,
+                    "positional_params": statement._positional_params,
+                    "named_params": statement._named_params,
+                }
+                if statement.parameters:
+                    return SQL(
+                        sql_source, parameters=statement.parameters, config=new_config, _existing_state=existing_state
+                    )
+                return SQL(sql_source, config=new_config, _existing_state=existing_state)
             return statement
-        return SQL(statement, *parameters, _dialect=self.dialect, _config=_config, **kwargs)
+        new_config = _config
+        if self.dialect and not new_config.dialect:
+            new_config = replace(new_config, dialect=self.dialect)
+        return SQL(statement, *parameters, config=new_config, **kwargs)
 
     @abstractmethod
     async def _execute_statement(
         self, statement: "SQL", connection: "Optional[ConnectionT]" = None, **kwargs: Any
-    ) -> "Union[SelectResultDict, DMLResultDict, ScriptResultDict]":
+    ) -> "SQLResult[RowT]":
         """Actual execution implementation by concrete drivers, using the raw connection.
 
-        Returns one of the standardized result dictionaries based on the statement type.
+        Returns SQLResult directly based on the statement type.
         """
         raise NotImplementedError
 
-    @abstractmethod
-    async def _wrap_select_result(
-        self,
-        statement: "SQL",
-        result: "SelectResultDict",
-        schema_type: "Optional[type[ModelDTOT]]" = None,
-        **kwargs: Any,
-    ) -> "Union[SQLResult[ModelDTOT], SQLResult[RowT]]":
-        raise NotImplementedError
-
-    @abstractmethod
-    async def _wrap_execute_result(
-        self, statement: "SQL", result: "Union[DMLResultDict, ScriptResultDict]", **kwargs: Any
-    ) -> "SQLResult[RowT]":
-        raise NotImplementedError
-
-    # Type-safe overloads based on the refactor plan pattern
     @overload
     async def execute(
         self,
-        statement: "SelectBuilder",
+        statement: "Select",
         /,
         *parameters: "Union[StatementParameters, StatementFilter]",
         schema_type: "type[ModelDTOT]",
@@ -96,7 +123,7 @@ class AsyncDriverAdapterProtocol(CommonDriverAttributesMixin[ConnectionT, RowT],
     @overload
     async def execute(
         self,
-        statement: "SelectBuilder",
+        statement: "Select",
         /,
         *parameters: "Union[StatementParameters, StatementFilter]",
         schema_type: None = None,
@@ -108,7 +135,7 @@ class AsyncDriverAdapterProtocol(CommonDriverAttributesMixin[ConnectionT, RowT],
     @overload
     async def execute(
         self,
-        statement: "Union[InsertBuilder, UpdateBuilder, DeleteBuilder]",
+        statement: "Union[Insert, Update, Delete]",
         /,
         *parameters: "Union[StatementParameters, StatementFilter]",
         _connection: "Optional[ConnectionT]" = None,
@@ -155,51 +182,45 @@ class AsyncDriverAdapterProtocol(CommonDriverAttributesMixin[ConnectionT, RowT],
             statement=sql_statement, connection=self._connection(_connection), **kwargs
         )
 
-        if self.returns_rows(sql_statement.expression):
-            return await self._wrap_select_result(
-                sql_statement, cast("SelectResultDict", result), schema_type=schema_type, **kwargs
+        # If schema_type is provided and we have data, convert it
+        if schema_type and result.data and can_convert_to_schema(self):
+            converted_data = list(self.to_schema(data=result.data, schema_type=schema_type))
+            return SQLResult[ModelDTOT](
+                statement=result.statement,
+                data=converted_data,
+                column_names=result.column_names,
+                rows_affected=result.rows_affected,
+                operation_type=result.operation_type,
+                last_inserted_id=result.last_inserted_id,
+                execution_time=result.execution_time,
+                metadata=result.metadata,
             )
-        return await self._wrap_execute_result(
-            sql_statement, cast("Union[DMLResultDict, ScriptResultDict]", result), **kwargs
-        )
+
+        return result
 
     async def execute_many(
         self,
-        statement: "Union[SQL, Statement, QueryBuilder[Any]]",  # QueryBuilder for DMLs will likely not return rows.
+        statement: "Union[SQL, Statement, QueryBuilder[Any]]",
         /,
         *parameters: "Union[StatementParameters, StatementFilter]",
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
         **kwargs: Any,
     ) -> "SQLResult[RowT]":
-        # Separate parameters from filters
-        param_sequences = []
-        filters = []
-        for param in parameters:
-            if isinstance(param, StatementFilter):
-                filters.append(param)
-            else:
-                param_sequences.append(param)
-
-        # Use first parameter as the sequence for execute_many
-        param_sequence = param_sequences[0] if param_sequences else None
-        # Convert tuple to list if needed
-        if isinstance(param_sequence, tuple):
-            param_sequence = list(param_sequence)
-        # Ensure param_sequence is a list or None
-        if param_sequence is not None and not isinstance(param_sequence, list):
-            param_sequence = list(param_sequence) if hasattr(param_sequence, "__iter__") else None
-        sql_statement = self._build_statement(statement, _config=_config or self.config, **kwargs)
-        sql_statement = sql_statement.as_many(param_sequence)
-        result = await self._execute_statement(
-            statement=sql_statement,
-            connection=self._connection(_connection),
-            parameters=param_sequence,
-            is_many=True,
-            **kwargs,
-        )
-        return await self._wrap_execute_result(
-            sql_statement, cast("Union[DMLResultDict, ScriptResultDict]", result), **kwargs
+        _filters, param_sequence = process_execute_many_parameters(parameters)
+
+        # For execute_many, disable transformations to prevent literal extraction
+        # since the SQL already has placeholders for bulk operations
+        many_config = _config or self.config
+        if many_config.enable_transformations:
+            from dataclasses import replace
+
+            many_config = replace(many_config, enable_transformations=False)
+
+        sql_statement = self._build_statement(statement, _config=many_config, **kwargs).as_many(param_sequence)
+
+        return await self._execute_statement(
+            statement=sql_statement, connection=self._connection(_connection), **kwargs
         )
 
     async def execute_script(
@@ -211,42 +232,12 @@ class AsyncDriverAdapterProtocol(CommonDriverAttributesMixin[ConnectionT, RowT],
         _config: "Optional[SQLConfig]" = None,
         **kwargs: Any,
     ) -> "SQLResult[RowT]":
-        param_values = []
-        filters = []
-        for param in parameters:
-            if isinstance(param, StatementFilter):
-                filters.append(param)
-            else:
-                param_values.append(param)
-
-        # Use first parameter as the primary parameter value, or None if no parameters
-        primary_params = param_values[0] if param_values else None
-
         script_config = _config or self.config
         if script_config.enable_validation:
-            script_config = SQLConfig(
-                enable_parsing=script_config.enable_parsing,
-                enable_validation=False,
-                enable_transformations=script_config.enable_transformations,
-                enable_analysis=script_config.enable_analysis,
-                strict_mode=False,
-                cache_parsed_expression=script_config.cache_parsed_expression,
-                parameter_converter=script_config.parameter_converter,
-                parameter_validator=script_config.parameter_validator,
-                analysis_cache_size=script_config.analysis_cache_size,
-                allowed_parameter_styles=script_config.allowed_parameter_styles,
-                target_parameter_style=script_config.target_parameter_style,
-                allow_mixed_parameter_styles=script_config.allow_mixed_parameter_styles,
-            )
-        sql_statement = SQL(statement, primary_params, *filters, _dialect=self.dialect, _config=script_config, **kwargs)
+            script_config = replace(script_config, enable_validation=False, strict_mode=False)
+
+        sql_statement = self._build_statement(statement, *parameters, _config=script_config, **kwargs)
         sql_statement = sql_statement.as_script()
-        script_output = await self._execute_statement(
-            statement=sql_statement, connection=self._connection(_connection), is_script=True, **kwargs
+        return await self._execute_statement(
+            statement=sql_statement, connection=self._connection(_connection), **kwargs
         )
-        if isinstance(script_output, str):
-            result = SQLResult[RowT](statement=sql_statement, data=[], operation_type="SCRIPT")
-            result.total_statements = 1
-            result.successful_statements = 1
-            return result
-        # Wrap the ScriptResultDict using the driver's wrapper
-        return await self._wrap_execute_result(sql_statement, cast("ScriptResultDict", script_output), **kwargs)