sqlspec 0.27.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

sqlspec/adapters/oracledb/adk/store.py

@@ -116,16 +116,31 @@ class OracleAsyncADKStore(BaseAsyncADKStore["OracleAsyncConfig"]):
             - session_table: Sessions table name (default: "adk_sessions")
             - events_table: Events table name (default: "adk_events")
             - owner_id_column: Optional owner FK column DDL (default: None)
-            - in_memory: Enable INMEMORY clause (default: False)
+            - in_memory: Enable INMEMORY PRIORITY HIGH clause (default: False)
         """
         super().__init__(config)
         self._json_storage_type: JSONStorageType | None = None
 
-        if hasattr(config, "extension_config") and config.extension_config:
-            adk_config = config.extension_config.get("adk", {})
-            self._in_memory: bool = bool(adk_config.get("in_memory", False))
-        else:
-            self._in_memory = False
+        adk_config = config.extension_config.get("adk", {})
+        self._in_memory: bool = bool(adk_config.get("in_memory", False))
+
+    async def _get_create_sessions_table_sql(self) -> str:
+        """Get Oracle CREATE TABLE SQL for sessions table.
+
+        Auto-detects optimal JSON storage type based on Oracle version.
+        Result is cached to minimize database queries.
+        """
+        storage_type = await self._detect_json_storage_type()
+        return self._get_create_sessions_table_sql_for_type(storage_type)
+
+    async def _get_create_events_table_sql(self) -> str:
+        """Get Oracle CREATE TABLE SQL for events table.
+
+        Auto-detects optimal JSON storage type based on Oracle version.
+        Result is cached to minimize database queries.
+        """
+        storage_type = await self._detect_json_storage_type()
+        return self._get_create_events_table_sql_for_type(storage_type)
 
     async def _detect_json_storage_type(self) -> JSONStorageType:
         """Detect the appropriate JSON storage type based on Oracle version.
@@ -292,7 +307,7 @@ class OracleAsyncADKStore(BaseAsyncADKStore["OracleAsyncConfig"]):
             state_column = "state BLOB NOT NULL"
 
         owner_id_column_sql = f", {self._owner_id_column_ddl}" if self._owner_id_column_ddl else ""
-        inmemory_clause = " INMEMORY" if self._in_memory else ""
+        inmemory_clause = " INMEMORY PRIORITY HIGH" if self._in_memory else ""
 
         return f"""
         BEGIN
@@ -363,7 +378,7 @@ class OracleAsyncADKStore(BaseAsyncADKStore["OracleAsyncConfig"]):
                 long_running_tool_ids_json BLOB
             """
 
-        inmemory_clause = " INMEMORY" if self._in_memory else ""
+        inmemory_clause = " INMEMORY PRIORITY HIGH" if self._in_memory else ""
 
         return f"""
         BEGIN
@@ -404,89 +419,6 @@ class OracleAsyncADKStore(BaseAsyncADKStore["OracleAsyncConfig"]):
         END;
         """
 
-    def _get_create_sessions_table_sql(self) -> str:
-        """Get Oracle CREATE TABLE SQL for sessions.
-
-        Returns:
-            SQL statement to create adk_sessions table with indexes.
-
-        Notes:
-            - VARCHAR2(128) for IDs and names
-            - CLOB with IS JSON constraint for state storage
-            - TIMESTAMP WITH TIME ZONE for timezone-aware timestamps
-            - SYSTIMESTAMP for default current timestamp
-            - Composite index on (app_name, user_id) for listing
-            - Index on update_time DESC for recent session queries
-        """
-        return f"""
-        BEGIN
-            EXECUTE IMMEDIATE 'CREATE TABLE {self._session_table} (
-                id VARCHAR2(128) PRIMARY KEY,
-                app_name VARCHAR2(128) NOT NULL,
-                user_id VARCHAR2(128) NOT NULL,
-                state CLOB CHECK (state IS JSON),
-                create_time TIMESTAMP WITH TIME ZONE DEFAULT SYSTIMESTAMP NOT NULL,
-                update_time TIMESTAMP WITH TIME ZONE DEFAULT SYSTIMESTAMP NOT NULL
-            )';
-        EXCEPTION
-            WHEN OTHERS THEN
-                IF SQLCODE != -955 THEN
-                    RAISE;
-                END IF;
-        END;
-        """
-
-    def _get_create_events_table_sql(self) -> str:
-        """Get Oracle CREATE TABLE SQL for events (legacy method).
-
-        Returns:
-            SQL statement to create adk_events table with indexes.
-
-        Notes:
-            DEPRECATED: Use _get_create_events_table_sql_for_type() instead.
-            This method uses BLOB with IS JSON constraints (12c+ compatible).
-
-            - VARCHAR2 sizes: id(128), session_id(128), invocation_id(256), author(256),
-              branch(256), error_code(256), error_message(1024)
-            - BLOB for pickled actions
-            - BLOB with IS JSON for all JSON fields (content, grounding_metadata,
-              custom_metadata, long_running_tool_ids_json)
-            - NUMBER(1) for partial, turn_complete, interrupted
-            - Foreign key to sessions with CASCADE delete
-            - Index on (session_id, timestamp ASC) for ordered event retrieval
-        """
-        return f"""
-        BEGIN
-            EXECUTE IMMEDIATE 'CREATE TABLE {self._events_table} (
-                id VARCHAR2(128) PRIMARY KEY,
-                session_id VARCHAR2(128) NOT NULL,
-                app_name VARCHAR2(128) NOT NULL,
-                user_id VARCHAR2(128) NOT NULL,
-                invocation_id VARCHAR2(256),
-                author VARCHAR2(256),
-                actions BLOB,
-                branch VARCHAR2(256),
-                timestamp TIMESTAMP WITH TIME ZONE DEFAULT SYSTIMESTAMP NOT NULL,
-                content BLOB CHECK (content IS JSON),
-                grounding_metadata BLOB CHECK (grounding_metadata IS JSON),
-                custom_metadata BLOB CHECK (custom_metadata IS JSON),
-                long_running_tool_ids_json BLOB CHECK (long_running_tool_ids_json IS JSON),
-                partial NUMBER(1),
-                turn_complete NUMBER(1),
-                interrupted NUMBER(1),
-                error_code VARCHAR2(256),
-                error_message VARCHAR2(1024),
-                CONSTRAINT fk_{self._events_table}_session FOREIGN KEY (session_id)
-                    REFERENCES {self._session_table}(id) ON DELETE CASCADE
-            )';
-        EXCEPTION
-            WHEN OTHERS THEN
-                IF SQLCODE != -955 THEN
-                    RAISE;
-                END IF;
-        END;
-        """
-
     def _get_drop_tables_sql(self) -> "list[str]":
         """Get Oracle DROP TABLE SQL statements.
 
@@ -561,8 +493,7 @@ class OracleAsyncADKStore(BaseAsyncADKStore["OracleAsyncConfig"]):
         logger.info("Creating ADK tables with storage type: %s", storage_type)
 
         async with self._config.provide_session() as driver:
-            sessions_sql = SQL(self._get_create_sessions_table_sql_for_type(storage_type))
-            await driver.execute_script(sessions_sql)
+            await driver.execute_script(self._get_create_sessions_table_sql_for_type(storage_type))
 
             await driver.execute_script(self._get_create_events_table_sql_for_type(storage_type))
 
@@ -704,32 +635,42 @@ class OracleAsyncADKStore(BaseAsyncADKStore["OracleAsyncConfig"]):
             await cursor.execute(sql, {"id": session_id})
             await conn.commit()
 
-    async def list_sessions(self, app_name: str, user_id: str) -> "list[SessionRecord]":
-        """List all sessions for a user in an app.
+    async def list_sessions(self, app_name: str, user_id: str | None = None) -> "list[SessionRecord]":
+        """List sessions for an app, optionally filtered by user.
 
         Args:
             app_name: Application name.
-            user_id: User identifier.
+            user_id: User identifier. If None, lists all sessions for the app.
 
         Returns:
             List of session records ordered by update_time DESC.
 
         Notes:
-            Uses composite index on (app_name, user_id).
+            Uses composite index on (app_name, user_id) when user_id is provided.
             State is deserialized using version-appropriate format.
         """
 
-        sql = f"""
-        SELECT id, app_name, user_id, state, create_time, update_time
-        FROM {self._session_table}
-        WHERE app_name = :app_name AND user_id = :user_id
-        ORDER BY update_time DESC
-        """
+        if user_id is None:
+            sql = f"""
+            SELECT id, app_name, user_id, state, create_time, update_time
+            FROM {self._session_table}
+            WHERE app_name = :app_name
+            ORDER BY update_time DESC
+            """
+            params = {"app_name": app_name}
+        else:
+            sql = f"""
+            SELECT id, app_name, user_id, state, create_time, update_time
+            FROM {self._session_table}
+            WHERE app_name = :app_name AND user_id = :user_id
+            ORDER BY update_time DESC
+            """
+            params = {"app_name": app_name, "user_id": user_id}
 
         try:
             async with self._config.provide_connection() as conn:
                 cursor = conn.cursor()
-                await cursor.execute(sql, {"app_name": app_name, "user_id": user_id})
+                await cursor.execute(sql, params)
                 rows = await cursor.fetchall()
 
                 results = []
@@ -953,16 +894,31 @@ class OracleSyncADKStore(BaseSyncADKStore["OracleSyncConfig"]):
             - session_table: Sessions table name (default: "adk_sessions")
             - events_table: Events table name (default: "adk_events")
             - owner_id_column: Optional owner FK column DDL (default: None)
-            - in_memory: Enable INMEMORY clause (default: False)
+            - in_memory: Enable INMEMORY PRIORITY HIGH clause (default: False)
         """
         super().__init__(config)
         self._json_storage_type: JSONStorageType | None = None
 
-        if hasattr(config, "extension_config") and config.extension_config:
-            adk_config = config.extension_config.get("adk", {})
-            self._in_memory: bool = bool(adk_config.get("in_memory", False))
-        else:
-            self._in_memory = False
+        adk_config = config.extension_config.get("adk", {})
+        self._in_memory: bool = bool(adk_config.get("in_memory", False))
+
+    def _get_create_sessions_table_sql(self) -> str:
+        """Get Oracle CREATE TABLE SQL for sessions table.
+
+        Auto-detects optimal JSON storage type based on Oracle version.
+        Result is cached to minimize database queries.
+        """
+        storage_type = self._detect_json_storage_type()
+        return self._get_create_sessions_table_sql_for_type(storage_type)
+
+    def _get_create_events_table_sql(self) -> str:
+        """Get Oracle CREATE TABLE SQL for events table.
+
+        Auto-detects optimal JSON storage type based on Oracle version.
+        Result is cached to minimize database queries.
+        """
+        storage_type = self._detect_json_storage_type()
+        return self._get_create_events_table_sql_for_type(storage_type)
 
     def _detect_json_storage_type(self) -> JSONStorageType:
         """Detect the appropriate JSON storage type based on Oracle version.
@@ -1129,7 +1085,7 @@ class OracleSyncADKStore(BaseSyncADKStore["OracleSyncConfig"]):
             state_column = "state BLOB NOT NULL"
 
         owner_id_column_sql = f", {self._owner_id_column_ddl}" if self._owner_id_column_ddl else ""
-        inmemory_clause = " INMEMORY" if self._in_memory else ""
+        inmemory_clause = " INMEMORY PRIORITY HIGH" if self._in_memory else ""
 
         return f"""
         BEGIN
@@ -1200,7 +1156,7 @@ class OracleSyncADKStore(BaseSyncADKStore["OracleSyncConfig"]):
                 long_running_tool_ids_json BLOB
             """
 
-        inmemory_clause = " INMEMORY" if self._in_memory else ""
+        inmemory_clause = " INMEMORY PRIORITY HIGH" if self._in_memory else ""
 
         return f"""
         BEGIN
@@ -1241,89 +1197,6 @@ class OracleSyncADKStore(BaseSyncADKStore["OracleSyncConfig"]):
         END;
         """
 
-    def _get_create_sessions_table_sql(self) -> str:
-        """Get Oracle CREATE TABLE SQL for sessions.
-
-        Returns:
-            SQL statement to create adk_sessions table with indexes.
-
-        Notes:
-            - VARCHAR2(128) for IDs and names
-            - CLOB with IS JSON constraint for state storage
-            - TIMESTAMP WITH TIME ZONE for timezone-aware timestamps
-            - SYSTIMESTAMP for default current timestamp
-            - Composite index on (app_name, user_id) for listing
-            - Index on update_time DESC for recent session queries
-        """
-        return f"""
-        BEGIN
-            EXECUTE IMMEDIATE 'CREATE TABLE {self._session_table} (
-                id VARCHAR2(128) PRIMARY KEY,
-                app_name VARCHAR2(128) NOT NULL,
-                user_id VARCHAR2(128) NOT NULL,
-                state CLOB CHECK (state IS JSON),
-                create_time TIMESTAMP WITH TIME ZONE DEFAULT SYSTIMESTAMP NOT NULL,
-                update_time TIMESTAMP WITH TIME ZONE DEFAULT SYSTIMESTAMP NOT NULL
-            )';
-        EXCEPTION
-            WHEN OTHERS THEN
-                IF SQLCODE != -955 THEN
-                    RAISE;
-                END IF;
-        END;
-        """
-
-    def _get_create_events_table_sql(self) -> str:
-        """Get Oracle CREATE TABLE SQL for events (legacy method).
-
-        Returns:
-            SQL statement to create adk_events table with indexes.
-
-        Notes:
-            DEPRECATED: Use _get_create_events_table_sql_for_type() instead.
-            This method uses BLOB with IS JSON constraints (12c+ compatible).
-
-            - VARCHAR2 sizes: id(128), session_id(128), invocation_id(256), author(256),
-              branch(256), error_code(256), error_message(1024)
-            - BLOB for pickled actions
-            - BLOB with IS JSON for all JSON fields (content, grounding_metadata,
-              custom_metadata, long_running_tool_ids_json)
-            - NUMBER(1) for partial, turn_complete, interrupted
-            - Foreign key to sessions with CASCADE delete
-            - Index on (session_id, timestamp ASC) for ordered event retrieval
-        """
-        return f"""
-        BEGIN
-            EXECUTE IMMEDIATE 'CREATE TABLE {self._events_table} (
-                id VARCHAR2(128) PRIMARY KEY,
-                session_id VARCHAR2(128) NOT NULL,
-                app_name VARCHAR2(128) NOT NULL,
-                user_id VARCHAR2(128) NOT NULL,
-                invocation_id VARCHAR2(256),
-                author VARCHAR2(256),
-                actions BLOB,
-                branch VARCHAR2(256),
-                timestamp TIMESTAMP WITH TIME ZONE DEFAULT SYSTIMESTAMP NOT NULL,
-                content BLOB CHECK (content IS JSON),
-                grounding_metadata BLOB CHECK (grounding_metadata IS JSON),
-                custom_metadata BLOB CHECK (custom_metadata IS JSON),
-                long_running_tool_ids_json BLOB CHECK (long_running_tool_ids_json IS JSON),
-                partial NUMBER(1),
-                turn_complete NUMBER(1),
-                interrupted NUMBER(1),
-                error_code VARCHAR2(256),
-                error_message VARCHAR2(1024),
-                CONSTRAINT fk_{self._events_table}_session FOREIGN KEY (session_id)
-                    REFERENCES {self._session_table}(id) ON DELETE CASCADE
-            )';
-        EXCEPTION
-            WHEN OTHERS THEN
-                IF SQLCODE != -955 THEN
-                    RAISE;
-                END IF;
-        END;
-        """
-
     def _get_drop_tables_sql(self) -> "list[str]":
         """Get Oracle DROP TABLE SQL statements.
 
@@ -1542,32 +1415,42 @@ class OracleSyncADKStore(BaseSyncADKStore["OracleSyncConfig"]):
             cursor.execute(sql, {"id": session_id})
             conn.commit()
 
-    def list_sessions(self, app_name: str, user_id: str) -> "list[SessionRecord]":
-        """List all sessions for a user in an app.
+    def list_sessions(self, app_name: str, user_id: str | None = None) -> "list[SessionRecord]":
+        """List sessions for an app, optionally filtered by user.
 
         Args:
             app_name: Application name.
-            user_id: User identifier.
+            user_id: User identifier. If None, lists all sessions for the app.
 
         Returns:
             List of session records ordered by update_time DESC.
 
         Notes:
-            Uses composite index on (app_name, user_id).
+            Uses composite index on (app_name, user_id) when user_id is provided.
             State is deserialized using version-appropriate format.
         """
 
-        sql = f"""
-        SELECT id, app_name, user_id, state, create_time, update_time
-        FROM {self._session_table}
-        WHERE app_name = :app_name AND user_id = :user_id
-        ORDER BY update_time DESC
-        """
+        if user_id is None:
+            sql = f"""
+            SELECT id, app_name, user_id, state, create_time, update_time
+            FROM {self._session_table}
+            WHERE app_name = :app_name
+            ORDER BY update_time DESC
+            """
+            params = {"app_name": app_name}
+        else:
+            sql = f"""
+            SELECT id, app_name, user_id, state, create_time, update_time
+            FROM {self._session_table}
+            WHERE app_name = :app_name AND user_id = :user_id
+            ORDER BY update_time DESC
+            """
+            params = {"app_name": app_name, "user_id": user_id}
 
         try:
             with self._config.provide_connection() as conn:
                 cursor = conn.cursor()
-                cursor.execute(sql, {"app_name": app_name, "user_id": user_id})
+                cursor.execute(sql, params)
                 rows = cursor.fetchall()
 
                 results = []

sqlspec/adapters/oracledb/driver.py

@@ -13,7 +13,8 @@ from sqlspec.adapters.oracledb.data_dictionary import OracleAsyncDataDictionary,
 from sqlspec.adapters.oracledb.type_converter import OracleTypeConverter
 from sqlspec.core.cache import get_cache_config
 from sqlspec.core.parameters import ParameterStyle, ParameterStyleConfig
-from sqlspec.core.statement import StatementConfig
+from sqlspec.core.result import create_arrow_result
+from sqlspec.core.statement import SQL, StatementConfig
 from sqlspec.driver import (
     AsyncDataDictionaryBase,
     AsyncDriverAdapterBase,
@@ -33,14 +34,18 @@ from sqlspec.exceptions import (
     TransactionError,
     UniqueViolationError,
 )
+from sqlspec.utils.module_loader import ensure_pyarrow
 from sqlspec.utils.serializers import to_json
 
 if TYPE_CHECKING:
     from contextlib import AbstractAsyncContextManager, AbstractContextManager
 
+    from sqlspec.builder import QueryBuilder
+    from sqlspec.core import StatementFilter
     from sqlspec.core.result import SQLResult
-    from sqlspec.core.statement import SQL
+    from sqlspec.core.statement import Statement
     from sqlspec.driver._common import ExecutionResult
+    from sqlspec.typing import StatementParameters
 
 logger = logging.getLogger(__name__)
 
@@ -587,6 +592,94 @@ class OracleSyncDriver(SyncDriverAdapterBase):
             msg = f"Failed to commit Oracle transaction: {e}"
             raise SQLSpecError(msg) from e
 
+    def select_to_arrow(
+        self,
+        statement: "Statement | QueryBuilder",
+        /,
+        *parameters: "StatementParameters | StatementFilter",
+        statement_config: "StatementConfig | None" = None,
+        return_format: str = "table",
+        native_only: bool = False,
+        batch_size: int | None = None,
+        arrow_schema: Any = None,
+        **kwargs: Any,
+    ) -> "Any":
+        """Execute query and return results as Apache Arrow format using Oracle native support.
+
+        This implementation uses Oracle's native fetch_df_all() method which returns
+        an OracleDataFrame with Arrow PyCapsule interface, providing zero-copy data
+        transfer and 5-10x performance improvement over dict conversion.
+
+        Args:
+            statement: SQL query string, Statement, or QueryBuilder
+            *parameters: Query parameters (same format as execute()/select())
+            statement_config: Optional statement configuration override
+            return_format: "table" for pyarrow.Table (default), "batches" for RecordBatch
+            native_only: If False, use base conversion path instead of native (default: False uses native)
+            batch_size: Rows per batch when using "batches" format
+            arrow_schema: Optional pyarrow.Schema for type casting
+            **kwargs: Additional keyword arguments
+
+        Returns:
+            ArrowResult containing pyarrow.Table or RecordBatch
+
+        Examples:
+            >>> result = driver.select_to_arrow(
+            ...     "SELECT * FROM users WHERE age > :1", (18,)
+            ... )
+            >>> df = result.to_pandas()
+            >>> print(df.head())
+        """
+        # Check pyarrow is available
+        ensure_pyarrow()
+
+        # If native_only=False explicitly passed, use base conversion path
+        if native_only is False:
+            return super().select_to_arrow(
+                statement,
+                *parameters,
+                statement_config=statement_config,
+                return_format=return_format,
+                native_only=native_only,
+                batch_size=batch_size,
+                arrow_schema=arrow_schema,
+                **kwargs,
+            )
+
+        import pyarrow as pa
+
+        # Prepare statement with parameters
+        config = statement_config or self.statement_config
+        prepared_statement = self.prepare_statement(statement, parameters, statement_config=config, kwargs=kwargs)
+        sql, prepared_parameters = self._get_compiled_sql(prepared_statement, config)
+
+        # Use Oracle's native fetch_df_all() for zero-copy Arrow transfer
+        oracle_df = self.connection.fetch_df_all(
+            statement=sql, parameters=prepared_parameters or [], arraysize=batch_size or 1000
+        )
+
+        # Convert OracleDataFrame to PyArrow Table using PyCapsule interface
+        arrow_table = pa.table(oracle_df)
+
+        # Apply schema casting if provided
+        if arrow_schema is not None:
+            if not isinstance(arrow_schema, pa.Schema):
+                msg = f"arrow_schema must be a pyarrow.Schema, got {type(arrow_schema).__name__}"
+                raise TypeError(msg)
+            arrow_table = arrow_table.cast(arrow_schema)
+
+        # Convert to batches if requested
+        if return_format == "batches":
+            batches = arrow_table.to_batches()
+            arrow_data: Any = batches[0] if batches else pa.RecordBatch.from_pydict({})
+        else:
+            arrow_data = arrow_table
+
+        # Get row count
+        rows_affected = len(arrow_table)
+
+        return create_arrow_result(statement=prepared_statement, data=arrow_data, rows_affected=rows_affected)
+
     @property
     def data_dictionary(self) -> "SyncDataDictionaryBase":
         """Get the data dictionary for this driver.
@@ -783,6 +876,94 @@ class OracleAsyncDriver(AsyncDriverAdapterBase):
             msg = f"Failed to commit Oracle transaction: {e}"
             raise SQLSpecError(msg) from e
 
+    async def select_to_arrow(
+        self,
+        statement: "Statement | QueryBuilder",
+        /,
+        *parameters: "StatementParameters | StatementFilter",
+        statement_config: "StatementConfig | None" = None,
+        return_format: str = "table",
+        native_only: bool = False,
+        batch_size: int | None = None,
+        arrow_schema: Any = None,
+        **kwargs: Any,
+    ) -> "Any":
+        """Execute query and return results as Apache Arrow format using Oracle native support.
+
+        This implementation uses Oracle's native fetch_df_all() method which returns
+        an OracleDataFrame with Arrow PyCapsule interface, providing zero-copy data
+        transfer and 5-10x performance improvement over dict conversion.
+
+        Args:
+            statement: SQL query string, Statement, or QueryBuilder
+            *parameters: Query parameters (same format as execute()/select())
+            statement_config: Optional statement configuration override
+            return_format: "table" for pyarrow.Table (default), "batches" for RecordBatch
+            native_only: If False, use base conversion path instead of native (default: False uses native)
+            batch_size: Rows per batch when using "batches" format
+            arrow_schema: Optional pyarrow.Schema for type casting
+            **kwargs: Additional keyword arguments
+
+        Returns:
+            ArrowResult containing pyarrow.Table or RecordBatch
+
+        Examples:
+            >>> result = await driver.select_to_arrow(
+            ...     "SELECT * FROM users WHERE age > :1", (18,)
+            ... )
+            >>> df = result.to_pandas()
+            >>> print(df.head())
+        """
+        # Check pyarrow is available
+        ensure_pyarrow()
+
+        # If native_only=False explicitly passed, use base conversion path
+        if native_only is False:
+            return await super().select_to_arrow(
+                statement,
+                *parameters,
+                statement_config=statement_config,
+                return_format=return_format,
+                native_only=native_only,
+                batch_size=batch_size,
+                arrow_schema=arrow_schema,
+                **kwargs,
+            )
+
+        import pyarrow as pa
+
+        # Prepare statement with parameters
+        config = statement_config or self.statement_config
+        prepared_statement = self.prepare_statement(statement, parameters, statement_config=config, kwargs=kwargs)
+        sql, prepared_parameters = self._get_compiled_sql(prepared_statement, config)
+
+        # Use Oracle's native fetch_df_all() for zero-copy Arrow transfer
+        oracle_df = await self.connection.fetch_df_all(
+            statement=sql, parameters=prepared_parameters or [], arraysize=batch_size or 1000
+        )
+
+        # Convert OracleDataFrame to PyArrow Table using PyCapsule interface
+        arrow_table = pa.table(oracle_df)
+
+        # Apply schema casting if provided
+        if arrow_schema is not None:
+            if not isinstance(arrow_schema, pa.Schema):
+                msg = f"arrow_schema must be a pyarrow.Schema, got {type(arrow_schema).__name__}"
+                raise TypeError(msg)
+            arrow_table = arrow_table.cast(arrow_schema)
+
+        # Convert to batches if requested
+        if return_format == "batches":
+            batches = arrow_table.to_batches()
+            arrow_data: Any = batches[0] if batches else pa.RecordBatch.from_pydict({})
+        else:
+            arrow_data = arrow_table
+
+        # Get row count
+        rows_affected = len(arrow_table)
+
+        return create_arrow_result(statement=prepared_statement, data=arrow_data, rows_affected=rows_affected)
+
     @property
     def data_dictionary(self) -> "AsyncDataDictionaryBase":
         """Get the data dictionary for this driver.