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

sqlspec/adapters/adbc/driver.py

@@ -2,12 +2,14 @@ import contextlib
 import logging
 from collections.abc import Iterator
 from contextlib import contextmanager
+from dataclasses import replace
 from decimal import Decimal
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
 from adbc_driver_manager.dbapi import Connection, Cursor
 
 from sqlspec.driver import SyncDriverAdapterProtocol
+from sqlspec.driver.connection import managed_transaction_sync
 from sqlspec.driver.mixins import (
     SQLTranslatorMixin,
     SyncPipelinedExecutionMixin,
@@ -15,11 +17,12 @@ from sqlspec.driver.mixins import (
     ToSchemaMixin,
     TypeCoercionMixin,
 )
+from sqlspec.driver.parameters import normalize_parameter_sequence
 from sqlspec.exceptions import wrap_exceptions
 from sqlspec.statement.parameters import ParameterStyle
-from sqlspec.statement.result import ArrowResult, DMLResultDict, ScriptResultDict, SelectResultDict, SQLResult
+from sqlspec.statement.result import ArrowResult, 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.serializers import to_json
 
 if TYPE_CHECKING:
@@ -65,8 +68,15 @@ class AdbcDriver(
         config: "Optional[SQLConfig]" = None,
         default_row_type: "type[DictRow]" = DictRow,
     ) -> None:
+        dialect = self._get_dialect(connection)
+        if config and not config.dialect:
+            config = replace(config, dialect=dialect)
+        elif not config:
+            # Create config with dialect
+            config = SQLConfig(dialect=dialect)
+
         super().__init__(connection=connection, config=config, default_row_type=default_row_type)
-        self.dialect: DialectType = self._get_dialect(connection)
+        self.dialect: DialectType = dialect
         self.default_parameter_style = self._get_parameter_style_for_dialect(self.dialect)
         # Override supported parameter styles based on actual dialect capabilities
         self.supported_parameter_styles = self._get_supported_parameter_styles_for_dialect(self.dialect)
@@ -169,13 +179,13 @@ class AdbcDriver(
 
     def _execute_statement(
         self, statement: SQL, connection: Optional["AdbcConnection"] = 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)
 
-        # Determine if we need to convert parameter style
         detected_styles = {p.style for p in statement.parameter_info}
+
         target_style = self.default_parameter_style
         unsupported_styles = detected_styles - set(self.supported_parameter_styles)
 
@@ -196,69 +206,107 @@ class AdbcDriver(
 
     def _execute(
         self, sql: str, parameters: Any, statement: SQL, connection: Optional["AdbcConnection"] = None, **kwargs: Any
-    ) -> Union[SelectResultDict, DMLResultDict]:
-        conn = self._connection(connection)
-        with self._get_cursor(conn) as cursor:
-            # ADBC expects parameters as a list for most drivers
-            if parameters is not None and not isinstance(parameters, (list, tuple)):
-                cursor_params = [parameters]
+    ) -> SQLResult[RowT]:
+        # 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:
+            normalized_params = normalize_parameter_sequence(parameters)
+            if normalized_params is not None and not isinstance(normalized_params, (list, tuple)):
+                cursor_params = [normalized_params]
             else:
-                cursor_params = parameters  # type: ignore[assignment]
-
-            try:
-                cursor.execute(sql, cursor_params or [])
-            except Exception as e:
-                # Rollback transaction on error for PostgreSQL to avoid "current transaction is aborted" errors
-                if self.dialect == "postgres":
-                    with contextlib.suppress(Exception):
-                        cursor.execute("ROLLBACK")
-                raise e from e
-
-            if self.returns_rows(statement.expression):
-                fetched_data = cursor.fetchall()
-                column_names = [col[0] for col in cursor.description or []]
-                result: SelectResultDict = {
-                    "data": fetched_data,
-                    "column_names": column_names,
-                    "rows_affected": len(fetched_data),
-                }
-                return result
-
-            dml_result: DMLResultDict = {"rows_affected": cursor.rowcount, "status_message": "OK"}
-            return dml_result
+                cursor_params = normalized_params
+
+            with self._get_cursor(txn_conn) as cursor:
+                try:
+                    cursor.execute(sql, cursor_params or [])
+                except Exception as e:
+                    # Rollback transaction on error for PostgreSQL to avoid "current transaction is aborted" errors
+                    if self.dialect == "postgres":
+                        with contextlib.suppress(Exception):
+                            cursor.execute("ROLLBACK")
+                    raise e from e
+
+                if self.returns_rows(statement.expression):
+                    fetched_data = cursor.fetchall()
+                    column_names = [col[0] for col in cursor.description or []]
+
+                    if fetched_data and isinstance(fetched_data[0], tuple):
+                        dict_data: list[dict[Any, Any]] = [dict(zip(column_names, row)) for row in fetched_data]
+                    else:
+                        dict_data = fetched_data  # type: ignore[assignment]
+
+                    return SQLResult(
+                        statement=statement,
+                        data=cast("list[RowT]", dict_data),
+                        column_names=column_names,
+                        rows_affected=len(dict_data),
+                        operation_type="SELECT",
+                    )
+
+                operation_type = self._determine_operation_type(statement)
+                return SQLResult(
+                    statement=statement,
+                    data=cast("list[RowT]", []),
+                    rows_affected=cursor.rowcount,
+                    operation_type=operation_type,
+                    metadata={"status_message": "OK"},
+                )
 
     def _execute_many(
         self, sql: str, param_list: Any, connection: Optional["AdbcConnection"] = None, **kwargs: Any
-    ) -> DMLResultDict:
-        conn = self._connection(connection)
-        with self._get_cursor(conn) as cursor:
-            try:
-                cursor.executemany(sql, param_list or [])
-            except Exception as e:
-                if self.dialect == "postgres":
-                    with contextlib.suppress(Exception):
-                        cursor.execute("ROLLBACK")
-                # Always re-raise the original exception
-                raise e from e
-
-            result: DMLResultDict = {"rows_affected": cursor.rowcount, "status_message": "OK"}
-            return result
+    ) -> SQLResult[RowT]:
+        # 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)
+
+            with self._get_cursor(txn_conn) as cursor:
+                try:
+                    cursor.executemany(sql, normalized_param_list or [])
+                except Exception as e:
+                    if self.dialect == "postgres":
+                        with contextlib.suppress(Exception):
+                            cursor.execute("ROLLBACK")
+                    # Always re-raise the original exception
+                    raise e from e
+
+                return SQLResult(
+                    statement=SQL(sql, _dialect=self.dialect),
+                    data=[],
+                    rows_affected=cursor.rowcount,
+                    operation_type="EXECUTE",
+                    metadata={"status_message": "OK"},
+                )
 
     def _execute_script(
         self, script: str, connection: Optional["AdbcConnection"] = None, **kwargs: Any
-    ) -> ScriptResultDict:
-        conn = self._connection(connection)
-        # ADBC drivers don't support multiple statements in a single execute
-        # Use the shared implementation to split the script
-        statements = self._split_script_statements(script)
-
-        executed_count = 0
-        with self._get_cursor(conn) as cursor:
-            for statement in statements:
-                executed_count += self._execute_single_script_statement(cursor, statement)
-
-        result: ScriptResultDict = {"statements_executed": executed_count, "status_message": "SCRIPT EXECUTED"}
-        return result
+    ) -> SQLResult[RowT]:
+        # 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:
+            # ADBC drivers don't support multiple statements in a single execute
+            statements = self._split_script_statements(script)
+
+            executed_count = 0
+            with self._get_cursor(txn_conn) as cursor:
+                for statement in statements:
+                    if statement.strip():
+                        self._execute_single_script_statement(cursor, statement)
+                        executed_count += 1
+
+            return SQLResult(
+                statement=SQL(script, _dialect=self.dialect).as_script(),
+                data=[],
+                rows_affected=0,
+                operation_type="SCRIPT",
+                metadata={"status_message": "SCRIPT EXECUTED"},
+                total_statements=executed_count,
+                successful_statements=executed_count,
+            )
 
     def _execute_single_script_statement(self, cursor: "Cursor", statement: str) -> int:
         """Execute a single statement from a script and handle errors.
@@ -273,7 +321,7 @@ class AdbcDriver(
         try:
             cursor.execute(statement)
         except Exception as e:
-            # Rollback transaction on error for PostgreSQL
+            # Rollback transaction on error for PostgreSQL to avoid "current transaction is aborted" errors
             if self.dialect == "postgres":
                 with contextlib.suppress(Exception):
                     cursor.execute("ROLLBACK")
@@ -281,59 +329,6 @@ class AdbcDriver(
         else:
             return 1
 
-    def _wrap_select_result(
-        self, statement: SQL, result: SelectResultDict, schema_type: Optional[type[ModelDTOT]] = None, **kwargs: Any
-    ) -> Union[SQLResult[ModelDTOT], SQLResult[RowT]]:
-        # result must be a dict with keys: data, column_names, rows_affected
-
-        rows_as_dicts = [dict(zip(result["column_names"], 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]:
-        operation_type = (
-            str(statement.expression.key).upper()
-            if statement.expression and hasattr(statement.expression, "key")
-            else "UNKNOWN"
-        )
-
-        # Handle TypedDict results
-        if is_dict_with_field(result, "statements_executed"):
-            return SQLResult[RowT](
-                statement=statement,
-                data=[],
-                rows_affected=0,
-                total_statements=result["statements_executed"],
-                operation_type="SCRIPT",  # Scripts always have operation_type SCRIPT
-                metadata={"status_message": result["status_message"]},
-            )
-        if is_dict_with_field(result, "rows_affected"):
-            return SQLResult[RowT](
-                statement=statement,
-                data=[],
-                rows_affected=result["rows_affected"],
-                operation_type=operation_type,
-                metadata={"status_message": result["status_message"]},
-            )
-        msg = f"Unexpected result type: {type(result)}"
-        raise ValueError(msg)
-
     def _fetch_arrow_table(self, sql: SQL, connection: "Optional[Any]" = None, **kwargs: Any) -> "ArrowResult":
         """ADBC native Arrow table fetching.
 
@@ -379,10 +374,17 @@ class AdbcDriver(
 
         conn = self._connection(None)
         with self._get_cursor(conn) as cursor:
-            # Handle different modes
             if mode == "replace":
-                cursor.execute(SQL(f"TRUNCATE TABLE {table_name}").to_sql(placeholder_style=ParameterStyle.STATIC))
+                cursor.execute(
+                    SQL(f"TRUNCATE TABLE {table_name}", _dialect=self.dialect).to_sql(
+                        placeholder_style=ParameterStyle.STATIC
+                    )
+                )
             elif mode == "create":
                 msg = "'create' mode is not supported for ADBC ingestion"
                 raise NotImplementedError(msg)
             return cursor.adbc_ingest(table_name, table, mode=mode, **options)  # type: ignore[arg-type]
+
+    def _connection(self, connection: Optional["AdbcConnection"] = None) -> "AdbcConnection":
+        """Get the connection to use for the operation."""
+        return connection or self.connection

sqlspec/adapters/aiosqlite/config.py

@@ -3,7 +3,6 @@
 import logging
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
-from dataclasses import replace
 from typing import TYPE_CHECKING, Any, ClassVar, Optional
 
 import aiosqlite
@@ -172,17 +171,31 @@ class AiosqliteConfig(AsyncDatabaseConfig[AiosqliteConnection, None, AiosqliteDr
             An AiosqliteDriver instance.
         """
         async with self.provide_connection(*args, **kwargs) as connection:
-            # Create statement config with parameter style info if not already set
             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)
 
     async def provide_pool(self, *args: Any, **kwargs: Any) -> None:
         """Aiosqlite doesn't support pooling."""
         return
+
+    def get_signature_namespace(self) -> "dict[str, type[Any]]":
+        """Get the signature namespace for Aiosqlite types.
+
+        This provides all Aiosqlite-specific types that Litestar needs to recognize
+        to avoid serialization attempts.
+
+        Returns:
+            Dictionary mapping type names to types.
+        """
+        namespace = super().get_signature_namespace()
+        namespace.update({"AiosqliteConnection": AiosqliteConnection})
+        return namespace

sqlspec/adapters/aiosqlite/driver.py

@@ -3,11 +3,12 @@ import logging
 from collections.abc import AsyncGenerator, Sequence
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Optional
 
 import aiosqlite
 
 from sqlspec.driver import AsyncDriverAdapterProtocol
+from sqlspec.driver.connection import managed_transaction_async
 from sqlspec.driver.mixins import (
     AsyncPipelinedExecutionMixin,
     AsyncStorageMixin,
@@ -15,10 +16,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
+from sqlspec.typing import DictRow, RowT
 from sqlspec.utils.serializers import to_json
 
 if TYPE_CHECKING:
@@ -97,22 +99,24 @@ class AiosqliteDriver(
 
     async def _execute_statement(
         self, statement: SQL, connection: Optional[AiosqliteConnection] = None, **kwargs: Any
-    ) -> Union[SelectResultDict, DMLResultDict, ScriptResultDict]:
+    ) -> SQLResult[RowT]:
         if statement.is_script:
             sql, _ = statement.compile(placeholder_style=ParameterStyle.STATIC)
             return await self._execute_script(sql, connection=connection, **kwargs)
 
-        # Determine if we need to convert parameter style
-        detected_styles = {p.style for p in statement.parameter_info}
+        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}
+
         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 detected_styles:
-            # Use the first detected style if all are supported
             # Prefer the first supported style found
             for style in detected_styles:
                 if style in self.supported_parameter_styles:
@@ -122,85 +126,111 @@ class AiosqliteDriver(
         if statement.is_many:
             sql, params = statement.compile(placeholder_style=target_style)
 
-            # Process parameter list through type coercion
             params = self._process_parameters(params)
 
             return await self._execute_many(sql, params, connection=connection, **kwargs)
 
         sql, params = statement.compile(placeholder_style=target_style)
 
-        # Process parameters through type coercion
         params = self._process_parameters(params)
 
         return await self._execute(sql, params, statement, connection=connection, **kwargs)
 
     async def _execute(
         self, sql: str, parameters: Any, statement: SQL, connection: Optional[AiosqliteConnection] = None, **kwargs: Any
-    ) -> Union[SelectResultDict, DMLResultDict]:
+    ) -> SQLResult[RowT]:
         conn = self._connection(connection)
-        # Convert parameters to the format expected by the SQL
-        # Note: SQL was already rendered with appropriate placeholder style in _execute_statement
-        if ":param_" in sql or (parameters and isinstance(parameters, dict)):
-            # SQL has named placeholders, ensure params are dict
-            converted_params = self._convert_parameters_to_driver_format(
-                sql, parameters, target_style=ParameterStyle.NAMED_COLON
-            )
-        else:
-            # SQL has positional placeholders, ensure params are list/tuple
-            converted_params = self._convert_parameters_to_driver_format(
-                sql, parameters, target_style=ParameterStyle.QMARK
-            )
-        async with self._get_cursor(conn) as cursor:
-            # Aiosqlite handles both dict and tuple parameters
-            await cursor.execute(sql, converted_params or ())
-            if self.returns_rows(statement.expression):
-                fetched_data = await cursor.fetchall()
-                column_names = [desc[0] for desc in cursor.description or []]
-                # Convert to list of dicts or tuples as expected by TypedDict
-                data_list: list[Any] = list(fetched_data) if fetched_data else []
-                result: SelectResultDict = {
-                    "data": data_list,
-                    "column_names": column_names,
-                    "rows_affected": len(data_list),
-                }
-                return result
-            dml_result: DMLResultDict = {"rows_affected": cursor.rowcount, "status_message": "OK"}
-            return dml_result
+
+        async with managed_transaction_async(conn, auto_commit=True) as txn_conn:
+            normalized_params = normalize_parameter_sequence(parameters)
+
+            # Extract the actual parameters from the normalized list
+            if normalized_params and len(normalized_params) == 1:
+                actual_params = normalized_params[0]
+            else:
+                actual_params = normalized_params
+
+            # AIOSQLite expects tuple or dict - handle parameter conversion
+            if ":param_" in sql or (isinstance(actual_params, dict)):
+                # SQL has named placeholders, ensure params are dict
+                converted_params = self._convert_parameters_to_driver_format(
+                    sql, actual_params, target_style=ParameterStyle.NAMED_COLON
+                )
+            else:
+                # SQL has positional placeholders, ensure params are list/tuple
+                converted_params = self._convert_parameters_to_driver_format(
+                    sql, actual_params, target_style=ParameterStyle.QMARK
+                )
+
+            async with self._get_cursor(txn_conn) as cursor:
+                # Aiosqlite handles both dict and tuple parameters
+                await cursor.execute(sql, converted_params or ())
+                if self.returns_rows(statement.expression):
+                    fetched_data = await cursor.fetchall()
+                    column_names = [desc[0] for desc in cursor.description or []]
+                    data_list: list[Any] = list(fetched_data) if fetched_data else []
+                    return SQLResult(
+                        statement=statement,
+                        data=data_list,
+                        column_names=column_names,
+                        rows_affected=len(data_list),
+                        operation_type="SELECT",
+                    )
+
+                return SQLResult(
+                    statement=statement,
+                    data=[],
+                    rows_affected=cursor.rowcount,
+                    operation_type=self._determine_operation_type(statement),
+                    metadata={"status_message": "OK"},
+                )
 
     async def _execute_many(
         self, sql: str, param_list: Any, connection: Optional[AiosqliteConnection] = None, **kwargs: Any
-    ) -> DMLResultDict:
-        conn = self._connection(connection)
-        logger.debug("Executing SQL (executemany): %s", sql)
-        if param_list:
-            logger.debug("Query parameters (batch): %s", param_list)
-
-        # Convert parameter list to proper format for executemany
-        params_list: list[tuple[Any, ...]] = []
-        if param_list and isinstance(param_list, Sequence):
-            for param_set in param_list:
-                param_set = cast("Any", param_set)
-                if isinstance(param_set, (list, tuple)):
-                    params_list.append(tuple(param_set))
-                elif param_set is None:
-                    params_list.append(())
-
-        async with self._get_cursor(conn) as cursor:
-            await cursor.executemany(sql, params_list)
-            result: DMLResultDict = {"rows_affected": cursor.rowcount, "status_message": "OK"}
-            return result
+    ) -> 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:
+            # Normalize parameter list using consolidated utility
+            normalized_param_list = normalize_parameter_sequence(param_list)
+
+            params_list: list[tuple[Any, ...]] = []
+            if normalized_param_list and isinstance(normalized_param_list, Sequence):
+                for param_set in normalized_param_list:
+                    if isinstance(param_set, (list, tuple)):
+                        params_list.append(tuple(param_set))
+                    elif param_set is None:
+                        params_list.append(())
+
+            async with self._get_cursor(txn_conn) as cursor:
+                await cursor.executemany(sql, params_list)
+                return SQLResult(
+                    statement=SQL(sql, _dialect=self.dialect),
+                    data=[],
+                    rows_affected=cursor.rowcount,
+                    operation_type="EXECUTE",
+                    metadata={"status_message": "OK"},
+                )
 
     async def _execute_script(
         self, script: str, connection: Optional[AiosqliteConnection] = None, **kwargs: Any
-    ) -> ScriptResultDict:
-        conn = self._connection(connection)
-        async with self._get_cursor(conn) as cursor:
-            await cursor.executescript(script)
-        result: ScriptResultDict = {
-            "statements_executed": -1,  # AIOSQLite doesn't provide this info
-            "status_message": "SCRIPT EXECUTED",
-        }
-        return result
+    ) -> 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:
+            async with self._get_cursor(txn_conn) as cursor:
+                await cursor.executescript(script)
+            return SQLResult(
+                statement=SQL(script, _dialect=self.dialect).as_script(),
+                data=[],
+                rows_affected=0,
+                operation_type="SCRIPT",
+                metadata={"status_message": "SCRIPT EXECUTED"},
+                total_statements=-1,  # AIOSQLite doesn't provide this info
+                successful_statements=-1,
+            )
 
     async def _bulk_load_file(self, file_path: Path, table_name: str, format: str, mode: str, **options: Any) -> int:
         """Database-specific bulk load implementation using storage backend."""
@@ -234,66 +264,6 @@ class AiosqliteDriver(
         finally:
             await conn.close()
 
-    async def _wrap_select_result(
-        self, statement: SQL, result: SelectResultDict, schema_type: "Optional[type[ModelDTOT]]" = None, **kwargs: Any
-    ) -> Union[SQLResult[ModelDTOT], SQLResult[RowT]]:
-        fetched_data = result["data"]
-        column_names = result["column_names"]
-        rows_affected = result["rows_affected"]
-
-        rows_as_dicts: list[dict[str, Any]] = [dict(row) for row in fetched_data]
-
-        if self.returns_rows(statement.expression):
-            converted_data_seq = self.to_schema(data=rows_as_dicts, schema_type=schema_type)
-            return SQLResult[ModelDTOT](
-                statement=statement,
-                data=list(converted_data_seq),
-                column_names=column_names,
-                rows_affected=rows_affected,
-                operation_type="SELECT",
-            )
-        return SQLResult[RowT](
-            statement=statement,
-            data=rows_as_dicts,
-            column_names=column_names,
-            rows_affected=rows_affected,
-            operation_type="SELECT",
-        )
-
-    async def _wrap_execute_result(
-        self, statement: SQL, result: Union[DMLResultDict, ScriptResultDict], **kwargs: Any
-    ) -> SQLResult[RowT]:
-        operation_type = "UNKNOWN"
-        if statement.expression:
-            operation_type = str(statement.expression.key).upper()
-
-        if "statements_executed" in result:
-            script_result = cast("ScriptResultDict", result)
-            return SQLResult[RowT](
-                statement=statement,
-                data=[],
-                rows_affected=0,
-                operation_type="SCRIPT",
-                total_statements=script_result.get("statements_executed", -1),
-                metadata={"status_message": script_result.get("status_message", "")},
-            )
-
-        if "rows_affected" in result:
-            dml_result = cast("DMLResultDict", result)
-            rows_affected = dml_result["rows_affected"]
-            status_message = dml_result["status_message"]
-            return SQLResult[RowT](
-                statement=statement,
-                data=[],
-                rows_affected=rows_affected,
-                operation_type=operation_type,
-                metadata={"status_message": status_message},
-            )
-
-        # This shouldn't happen with TypedDict approach
-        msg = f"Unexpected result type: {type(result)}"
-        raise ValueError(msg)
-
     def _connection(self, connection: Optional[AiosqliteConnection] = None) -> AiosqliteConnection:
         """Get the connection to use for the operation."""
         return connection or self.connection