From 0a09291547db7e2e7bf33e955f83a3cab8763cff Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Fri, 14 Nov 2025 10:52:21 +0300
Subject: [PATCH 01/14] add: async traits for driver, db, connection, stmt and
 implement it for DataFusion driver

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/core/src/lib.rs                          |   1 +
 rust/core/src/non_blocking.rs                 | 470 ++++++++++++++++++
 rust/driver/datafusion/src/lib.rs             | 305 +++++-------
 rust/driver/datafusion/src/syncify.rs         | 338 +++++++++++++
 .../datafusion/tests/test_datafusion.rs       | 182 ++++---
 5 files changed, 1044 insertions(+), 252 deletions(-)
 create mode 100644 rust/core/src/non_blocking.rs
 create mode 100644 rust/driver/datafusion/src/syncify.rs

diff --git a/rust/core/src/lib.rs b/rust/core/src/lib.rs
index c8df8a9c18..c9e599c920 100644
--- a/rust/core/src/lib.rs
+++ b/rust/core/src/lib.rs
@@ -41,6 +41,7 @@
 
 pub mod constants;
 pub mod error;
+pub mod non_blocking;
 pub mod options;
 pub mod schemas;
 
diff --git a/rust/core/src/non_blocking.rs b/rust/core/src/non_blocking.rs
new file mode 100644
index 0000000000..96683cc9af
--- /dev/null
+++ b/rust/core/src/non_blocking.rs
@@ -0,0 +1,470 @@
+use arrow_array::{RecordBatch, RecordBatchReader};
+use arrow_schema::Schema;
+
+use std::collections::HashSet;
+use std::future::Future;
+
+use crate::error::Result;
+use crate::options::{self, *};
+use crate::PartitionedResult;
+
+/// Ability to configure an object by setting/getting options.
+pub trait AsyncOptionable {
+    type Option: AsRef<str> + Send;
+
+    /// Set a post-init option.
+    fn set_option(
+        &mut self,
+        key: Self::Option,
+        value: OptionValue,
+    ) -> impl Future<Output = Result<()>> + Send;
+
+    /// Get a string option value by key.
+    fn get_option_string(&self, key: Self::Option) -> impl Future<Output = Result<String>>;
+
+    /// Get a bytes option value by key.
+    fn get_option_bytes(&self, key: Self::Option) -> impl Future<Output = Result<Vec<u8>>>;
+
+    /// Get an integer option value by key.
+    fn get_option_int(&self, key: Self::Option) -> impl Future<Output = Result<i64>>;
+
+    /// Get a float option value by key.
+    fn get_option_double(&self, key: Self::Option) -> impl Future<Output = Result<f64>>;
+}
+
+/// A handle to an async ADBC driver.
+pub trait AsyncDriver {
+    type DatabaseType: AsyncDatabase + Send;
+
+    /// Allocate and initialize a new database without pre-init options.
+    fn new_database(&mut self) -> impl Future<Output = Result<Self::DatabaseType>> + Send;
+
+    /// Allocate and initialize a new database with pre-init options.
+    fn new_database_with_opts(
+        &mut self,
+        opts: Vec<(options::OptionDatabase, OptionValue)>,
+    ) -> impl Future<Output = Result<Self::DatabaseType>> + Send;
+}
+
+/// A handle to an async ADBC database.
+///
+/// Databases hold state shared by multiple connections. This typically means
+/// configuration and caches. For in-memory databases, it provides a place to
+/// hold ownership of the in-memory database.
+///
+/// Databases must be kept alive as long as any connections exist.
+pub trait AsyncDatabase: AsyncOptionable<Option = OptionDatabase> {
+    type ConnectionType: AsyncConnection + Send;
+
+    /// Allocate and initialize a new connection without pre-init options.
+    fn new_connection(&self) -> impl Future<Output = Result<Self::ConnectionType>> + Send;
+
+    /// Allocate and initialize a new connection with pre-init options.
+    fn new_connection_with_opts(
+        &self,
+        opts: Vec<(options::OptionConnection, OptionValue)>,
+    ) -> impl Future<Output = Result<Self::ConnectionType>> + Send;
+}
+
+/// A handle to an async ADBC connection.
+///
+/// Connections provide methods for query execution, managing prepared
+/// statements, using transactions, and so on.
+///
+/// # Autocommit
+///
+/// Connections should start in autocommit mode. They can be moved out by
+/// setting [options::OptionConnection::AutoCommit] to "false". Turning off
+/// autocommit allows customizing the isolation level.
+pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
+    type StatementType: AsyncStatement + Send;
+
+    /// Allocate and initialize a new statement.
+    fn new_statement(&mut self) -> impl Future<Output = Result<Self::StatementType>> + Send;
+
+    /// Cancel the in-progress operation on a connection.
+    fn cancel(&mut self) -> impl Future<Output = Result<()>> + Send;
+
+    /// Get metadata about the database/driver.
+    ///
+    /// # Arguments
+    ///
+    /// - `codes` - Requested metadata. If `None`, retrieve all available metadata.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// Field Name                  | Field Type
+    /// ----------------------------|------------------------
+    /// info_name                   | uint32 not null
+    /// info_value                  | INFO_SCHEMA
+    ///
+    /// INFO_SCHEMA is a dense union with members:
+    ///
+    /// Field Name (Type Code)      | Field Type
+    /// ----------------------------|------------------------
+    /// string_value (0)            | utf8
+    /// bool_value (1)              | bool
+    /// int64_value (2)             | int64
+    /// int32_bitmask (3)           | int32
+    /// string_list (4)             | list\<utf8\>
+    /// int32_to_int32_list_map (5) | map\<int32, list\<int32\>\>
+    fn get_info(
+        &self,
+        codes: Option<HashSet<options::InfoCode>>,
+    ) -> impl Future<Output = Result<impl RecordBatchReader + Send>>;
+
+    /// Get a hierarchical view of all catalogs, database schemas, tables, and
+    /// columns.
+    ///
+    /// # Arguments
+    ///
+    /// - `depth` - The level of nesting to query.
+    /// - `catalog` - Only show tables in the given catalog. If `None`,
+    ///   do not filter by catalog. If an empty string, only show tables
+    ///   without a catalog.  May be a search pattern.
+    /// - `db_schema` - Only show tables in the given database schema. If
+    ///   `None`, do not filter by database schema. If an empty string, only show
+    ///   tables without a database schema. May be a search pattern.
+    /// - `table_name` - Only show tables with the given name. If `None`, do not
+    ///   filter by name. May be a search pattern.
+    /// - `table_type` - Only show tables matching one of the given table
+    ///   types. If `None`, show tables of any type. Valid table types can be fetched
+    ///   from [Connection::get_table_types].
+    /// - `column_name` - Only show columns with the given name. If
+    ///   `None`, do not filter by name.  May be a search pattern..
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// | Field Name               | Field Type               |
+    /// |--------------------------|--------------------------|
+    /// | catalog_name             | utf8                     |
+    /// | catalog_db_schemas       | list\<DB_SCHEMA_SCHEMA\> |
+    ///
+    /// DB_SCHEMA_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              |
+    /// |--------------------------|-------------------------|
+    /// | db_schema_name           | utf8                    |
+    /// | db_schema_tables         | list\<TABLE_SCHEMA\>    |
+    ///
+    /// TABLE_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type                |
+    /// |--------------------------|---------------------------|
+    /// | table_name               | utf8 not null             |
+    /// | table_type               | utf8 not null             |
+    /// | table_columns            | list\<COLUMN_SCHEMA\>     |
+    /// | table_constraints        | list\<CONSTRAINT_SCHEMA\> |
+    ///
+    /// COLUMN_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              | Comments |
+    /// |--------------------------|-------------------------|----------|
+    /// | column_name              | utf8 not null           |          |
+    /// | ordinal_position         | int32                   | (1)      |
+    /// | remarks                  | utf8                    | (2)      |
+    /// | xdbc_data_type           | int16                   | (3)      |
+    /// | xdbc_type_name           | utf8                    | (3)      |
+    /// | xdbc_column_size         | int32                   | (3)      |
+    /// | xdbc_decimal_digits      | int16                   | (3)      |
+    /// | xdbc_num_prec_radix      | int16                   | (3)      |
+    /// | xdbc_nullable            | int16                   | (3)      |
+    /// | xdbc_column_def          | utf8                    | (3)      |
+    /// | xdbc_sql_data_type       | int16                   | (3)      |
+    /// | xdbc_datetime_sub        | int16                   | (3)      |
+    /// | xdbc_char_octet_length   | int32                   | (3)      |
+    /// | xdbc_is_nullable         | utf8                    | (3)      |
+    /// | xdbc_scope_catalog       | utf8                    | (3)      |
+    /// | xdbc_scope_schema        | utf8                    | (3)      |
+    /// | xdbc_scope_table         | utf8                    | (3)      |
+    /// | xdbc_is_autoincrement    | bool                    | (3)      |
+    /// | xdbc_is_generatedcolumn  | bool                    | (3)      |
+    ///
+    /// 1. The column's ordinal position in the table (starting from 1).
+    /// 2. Database-specific description of the column.
+    /// 3. Optional value.  Should be null if not supported by the driver.
+    ///    `xdbc_` values are meant to provide JDBC/ODBC-compatible metadata
+    ///    in an agnostic manner.
+    ///
+    /// CONSTRAINT_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              | Comments |
+    /// |--------------------------|-------------------------|----------|
+    /// | constraint_name          | utf8                    |          |
+    /// | constraint_type          | utf8 not null           | (1)      |
+    /// | constraint_column_names  | list\<utf8\> not null     | (2)      |
+    /// | constraint_column_usage  | list\<USAGE_SCHEMA\>      | (3)      |
+    ///
+    /// 1. One of `CHECK`, `FOREIGN KEY`, `PRIMARY KEY`, or `UNIQUE`.
+    /// 2. The columns on the current table that are constrained, in
+    ///    order.
+    /// 3. For `FOREIGN KEY` only, the referenced table and columns.
+    ///
+    /// USAGE_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              |
+    /// |--------------------------|-------------------------|
+    /// | fk_catalog               | utf8                    |
+    /// | fk_db_schema             | utf8                    |
+    /// | fk_table                 | utf8 not null           |
+    /// | fk_column_name           | utf8 not null           |
+    ///
+    fn get_objects(
+        &self,
+        depth: options::ObjectDepth,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        table_type: Option<Vec<&str>>,
+        column_name: Option<&str>,
+    ) -> impl Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+
+    /// Get the Arrow schema of a table.
+    ///
+    /// # Arguments
+    ///
+    /// - `catalog` - The catalog (or `None` if not applicable).
+    /// - `db_schema` - The database schema (or `None` if not applicable).
+    /// - `table_name` - The table name.
+    fn get_table_schema(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: &str,
+    ) -> impl Future<Output = Result<Schema>> + Send;
+
+    /// Get a list of table types in the database.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// Field Name     | Field Type
+    /// ---------------|--------------
+    /// table_type     | utf8 not null
+    fn get_table_types(&self)
+        -> impl Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+
+    /// Get the names of statistics specific to this driver.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// Field Name     | Field Type
+    /// ---------------|----------------
+    /// statistic_name | utf8 not null
+    /// statistic_key  | int16 not null
+    ///
+    /// # Since
+    /// ADBC API revision 1.1.0
+    fn get_statistic_names(
+        &self,
+    ) -> impl Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+
+    /// Get statistics about the data distribution of table(s).
+    ///
+    /// # Arguments
+    ///
+    /// - `catalog` - The catalog (or `None` if not applicable). May be a search pattern.
+    /// - `db_schema` - The database schema (or `None` if not applicable). May be a search pattern
+    /// - `table_name` - The table name (or `None` if not applicable). May be a search pattern
+    /// - `approximate` - If false, request exact values of statistics, else
+    ///   allow for best-effort, approximate, or cached values. The database may
+    ///   return approximate values regardless, as indicated in the result.
+    ///   Requesting exact values may be expensive or unsupported.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// | Field Name               | Field Type                       |
+    /// |--------------------------|----------------------------------|
+    /// | catalog_name             | utf8                             |
+    /// | catalog_db_schemas       | list\<DB_SCHEMA_SCHEMA\> not null|
+    ///
+    /// DB_SCHEMA_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type                        |
+    /// |--------------------------|-----------------------------------|
+    /// | db_schema_name           | utf8                              |
+    /// | db_schema_statistics     | list\<STATISTICS_SCHEMA\> not null|
+    ///
+    /// STATISTICS_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type                       | Comments |
+    /// |--------------------------|----------------------------------| -------- |
+    /// | table_name               | utf8 not null                    |          |
+    /// | column_name              | utf8                             | (1)      |
+    /// | statistic_key            | int16 not null                   | (2)      |
+    /// | statistic_value          | VALUE_SCHEMA not null            |          |
+    /// | statistic_is_approximate | bool not null                    | (3)      |
+    ///
+    /// 1. If null, then the statistic applies to the entire table.
+    /// 2. A dictionary-encoded statistic name (although we do not use the Arrow
+    ///    dictionary type). Values in [0, 1024) are reserved for ADBC.  Other
+    ///    values are for implementation-specific statistics.  For the definitions
+    ///    of predefined statistic types, see [options::Statistics]. To get
+    ///    driver-specific statistic names, use [Connection::get_statistic_names].
+    /// 3. If true, then the value is approximate or best-effort.
+    ///
+    /// VALUE_SCHEMA is a dense union with members:
+    ///
+    /// | Field Name               | Field Type                       |
+    /// |--------------------------|----------------------------------|
+    /// | int64                    | int64                            |
+    /// | uint64                   | uint64                           |
+    /// | float64                  | float64                          |
+    /// | binary                   | binary                           |
+    ///
+    /// # Since
+    ///
+    /// ADBC API revision 1.1.0
+    fn get_statistics(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        approximate: bool,
+    ) -> impl Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+
+    /// Commit any pending transactions. Only used if autocommit is disabled.
+    ///
+    /// Behavior is undefined if this is mixed with SQL transaction statements.
+    fn commit(&mut self) -> impl Future<Output = Result<()>> + Send;
+
+    /// Roll back any pending transactions. Only used if autocommit is disabled.
+    ///
+    /// Behavior is undefined if this is mixed with SQL transaction statements.
+    fn rollback(&mut self) -> impl Future<Output = Result<()>> + Send;
+
+    /// Retrieve a given partition of data.
+    ///
+    /// A partition can be retrieved from [Statement::execute_partitions].
+    ///
+    /// # Arguments
+    ///
+    /// - `partition` - The partition descriptor.
+    fn read_partition(
+        &self,
+        partition: impl AsRef<[u8]> + Send,
+    ) -> impl Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+}
+
+/// A handle to an async ADBC statement.
+///
+/// A statement is a container for all state needed to execute a database query,
+/// such as the query itself, parameters for prepared statements, driver
+/// parameters, etc.
+///
+/// Statements may represent queries or prepared statements.
+///
+/// Statements may be used multiple times and can be reconfigured
+/// (e.g. they can be reused to execute multiple different queries).
+/// However, executing a statement (and changing certain other state)
+/// will invalidate result sets obtained prior to that execution.
+///
+/// Multiple statements may be created from a single connection.
+/// However, the driver may block or error if they are used concurrently
+/// (whether from a single thread or multiple threads).
+pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> {
+    /// Bind Arrow data. This can be used for bulk inserts or prepared
+    /// statements.
+    fn bind(&mut self, batch: RecordBatch) -> impl Future<Output = Result<()>> + Send;
+
+    /// Bind Arrow data. This can be used for bulk inserts or prepared
+    /// statements.
+    // TODO(alexandreyc): should we use a generic here instead of a trait object?
+    // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567750972
+    fn bind_stream(
+        &mut self,
+        reader: Box<dyn RecordBatchReader + Send>,
+    ) -> impl Future<Output = Result<()>> + Send;
+
+    /// Execute a statement and get the results.
+    ///
+    /// This invalidates any prior result sets.
+    // TODO(alexandreyc): is the Send bound absolutely necessary? same question
+    // for all methods that return an impl RecordBatchReader
+    // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567748242
+    fn execute(&mut self) -> impl Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+
+    /// Execute a statement that doesn’t have a result set and get the number
+    /// of affected rows.
+    ///
+    /// This invalidates any prior result sets.
+    ///
+    /// # Result
+    ///
+    /// Will return the number of rows affected. If the affected row count is
+    /// unknown or unsupported by the database, will return `None`.
+    fn execute_update(&mut self) -> impl Future<Output = Result<Option<i64>>> + Send;
+
+    /// Get the schema of the result set of a query without executing it.
+    ///
+    /// This invalidates any prior result sets.
+    ///
+    /// Depending on the driver, this may require first executing
+    /// [Statement::prepare].
+    ///
+    /// # Since
+    ///
+    /// ADBC API revision 1.1.0
+    fn execute_schema(&mut self) -> impl Future<Output = Result<Schema>> + Send;
+
+    /// Execute a statement and get the results as a partitioned result set.
+    fn execute_partitions(&mut self) -> impl Future<Output = Result<PartitionedResult>> + Send;
+
+    /// Get the schema for bound parameters.
+    ///
+    /// This retrieves an Arrow schema describing the number, names, and
+    /// types of the parameters in a parameterized statement. The fields
+    /// of the schema should be in order of the ordinal position of the
+    /// parameters; named parameters should appear only once.
+    ///
+    /// If the parameter does not have a name, or the name cannot be
+    /// determined, the name of the corresponding field in the schema will
+    /// be an empty string. If the type cannot be determined, the type of
+    /// the corresponding field will be NA (NullType).
+    ///
+    /// This should be called after [Statement::prepare].
+    fn get_parameter_schema(&self) -> impl Future<Output = Result<Schema>> + Send;
+
+    /// Turn this statement into a prepared statement to be executed multiple
+    /// times.
+    ///
+    /// This invalidates any prior result sets.
+    fn prepare(&mut self) -> impl Future<Output = Result<()>> + Send;
+
+    /// Set the SQL query to execute.
+    ///
+    /// The query can then be executed with [Statement::execute]. For queries
+    /// expected to be executed repeatedly, call [Statement::prepare] first.
+    fn set_sql_query(
+        &mut self,
+        query: impl AsRef<str> + Send,
+    ) -> impl Future<Output = Result<()>> + Send;
+
+    /// Set the Substrait plan to execute.
+    ///
+    /// The query can then be executed with [Statement::execute]. For queries
+    /// expected to be executed repeatedly, call [Statement::prepare] first.
+    fn set_substrait_plan(
+        &mut self,
+        plan: impl AsRef<[u8]> + Send,
+    ) -> impl Future<Output = Result<()>>;
+
+    /// Cancel execution of an in-progress query.
+    ///
+    /// This can be called during [Statement::execute] (or similar), or while
+    /// consuming a result set returned from such.
+    ///
+    /// # Since
+    ///
+    /// ADBC API revision 1.1.0
+    fn cancel(&mut self) -> impl Future<Output = Result<()>>;
+}
diff --git a/rust/driver/datafusion/src/lib.rs b/rust/driver/datafusion/src/lib.rs
index c08ba28c70..be9ffaf469 100644
--- a/rust/driver/datafusion/src/lib.rs
+++ b/rust/driver/datafusion/src/lib.rs
@@ -14,10 +14,14 @@
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
-
 #![allow(refining_impl_trait)]
 
-use adbc_core::constants;
+mod syncify;
+
+use adbc_core::non_blocking::{
+    AsyncConnection, AsyncDatabase, AsyncDriver, AsyncOptionable, AsyncStatement,
+};
+use adbc_core::{constants, options};
 use datafusion::dataframe::DataFrameWriteOptions;
 use datafusion::datasource::TableType;
 use datafusion::prelude::*;
@@ -45,7 +49,7 @@ use adbc_core::{
     options::{
         InfoCode, ObjectDepth, OptionConnection, OptionDatabase, OptionStatement, OptionValue,
     },
-    schemas, Connection, Database, Driver, Optionable, Statement,
+    schemas,
 };
 
 pub enum Runtime {
@@ -134,52 +138,42 @@ impl RecordBatchReader for DataFusionReader {
 }
 
 #[derive(Default)]
-pub struct DataFusionDriver {
-    handle: Option<tokio::runtime::Handle>,
-}
+pub struct DataFusionDriver {}
 
 impl DataFusionDriver {
-    pub fn new(handle: Option<tokio::runtime::Handle>) -> Self {
-        Self { handle }
+    pub fn new() -> Self {
+        Self {}
     }
 }
 
-impl Driver for DataFusionDriver {
+impl AsyncDriver for DataFusionDriver {
     type DatabaseType = DataFusionDatabase;
 
-    fn new_database(&mut self) -> Result<Self::DatabaseType> {
-        Ok(Self::DatabaseType {
-            handle: self.handle.clone(),
-        })
+    async fn new_database(&mut self) -> Result<Self::DatabaseType> {
+        Ok(Self::DatabaseType {})
     }
 
-    fn new_database_with_opts(
+    async fn new_database_with_opts(
         &mut self,
-        opts: impl IntoIterator<
-            Item = (
-                adbc_core::options::OptionDatabase,
-                adbc_core::options::OptionValue,
-            ),
-        >,
+        opts: Vec<(
+            adbc_core::options::OptionDatabase,
+            adbc_core::options::OptionValue,
+        )>,
     ) -> adbc_core::error::Result<Self::DatabaseType> {
-        let mut database = Self::DatabaseType {
-            handle: self.handle.clone(),
-        };
+        let mut database = Self::DatabaseType {};
         for (key, value) in opts {
-            database.set_option(key, value)?;
+            database.set_option(key, value).await?;
         }
         Ok(database)
     }
 }
 
-pub struct DataFusionDatabase {
-    handle: Option<tokio::runtime::Handle>,
-}
+pub struct DataFusionDatabase {}
 
-impl Optionable for DataFusionDatabase {
+impl AsyncOptionable for DataFusionDatabase {
     type Option = OptionDatabase;
 
-    fn set_option(
+    async fn set_option(
         &mut self,
         key: Self::Option,
         _value: adbc_core::options::OptionValue,
@@ -190,28 +184,28 @@ impl Optionable for DataFusionDatabase {
         ))
     }
 
-    fn get_option_string(&self, key: Self::Option) -> adbc_core::error::Result<String> {
+    async fn get_option_string(&self, key: Self::Option) -> adbc_core::error::Result<String> {
         Err(Error::with_message_and_status(
             format!("Unrecognized option: {key:?}"),
             Status::NotFound,
         ))
     }
 
-    fn get_option_bytes(&self, key: Self::Option) -> adbc_core::error::Result<Vec<u8>> {
+    async fn get_option_bytes(&self, key: Self::Option) -> adbc_core::error::Result<Vec<u8>> {
         Err(Error::with_message_and_status(
             format!("Unrecognized option: {key:?}"),
             Status::NotFound,
         ))
     }
 
-    fn get_option_int(&self, key: Self::Option) -> adbc_core::error::Result<i64> {
+    async fn get_option_int(&self, key: Self::Option) -> adbc_core::error::Result<i64> {
         Err(Error::with_message_and_status(
             format!("Unrecognized option: {key:?}"),
             Status::NotFound,
         ))
     }
 
-    fn get_option_double(&self, key: Self::Option) -> adbc_core::error::Result<f64> {
+    async fn get_option_double(&self, key: Self::Option) -> adbc_core::error::Result<f64> {
         Err(Error::with_message_and_status(
             format!("Unrecognized option: {key:?}"),
             Status::NotFound,
@@ -219,40 +213,25 @@ impl Optionable for DataFusionDatabase {
     }
 }
 
-impl Database for DataFusionDatabase {
+impl AsyncDatabase for DataFusionDatabase {
     type ConnectionType = DataFusionConnection;
 
-    fn new_connection(&self) -> Result<Self::ConnectionType> {
+    async fn new_connection(&self) -> Result<Self::ConnectionType> {
         let ctx = SessionContext::new();
 
-        let runtime = Runtime::new(self.handle.clone()).unwrap();
-
-        Ok(DataFusionConnection {
-            runtime: Arc::new(runtime),
-            ctx: Arc::new(ctx),
-        })
+        Ok(DataFusionConnection { ctx: Arc::new(ctx) })
     }
 
-    fn new_connection_with_opts(
+    async fn new_connection_with_opts(
         &self,
-        opts: impl IntoIterator<
-            Item = (
-                adbc_core::options::OptionConnection,
-                adbc_core::options::OptionValue,
-            ),
-        >,
+        opts: Vec<(options::OptionConnection, OptionValue)>,
     ) -> adbc_core::error::Result<Self::ConnectionType> {
         let ctx = SessionContext::new();
 
-        let runtime = Runtime::new(self.handle.clone()).unwrap();
-
-        let mut connection = DataFusionConnection {
-            runtime: Arc::new(runtime),
-            ctx: Arc::new(ctx),
-        };
+        let mut connection = DataFusionConnection { ctx: Arc::new(ctx) };
 
         for (key, value) in opts {
-            connection.set_option(key, value)?;
+            connection.set_option(key, value).await?;
         }
 
         Ok(connection)
@@ -260,14 +239,13 @@ impl Database for DataFusionDatabase {
 }
 
 pub struct DataFusionConnection {
-    runtime: Arc<Runtime>,
     ctx: Arc<SessionContext>,
 }
 
-impl Optionable for DataFusionConnection {
+impl AsyncOptionable for DataFusionConnection {
     type Option = OptionConnection;
 
-    fn set_option(
+    async fn set_option(
         &mut self,
         key: Self::Option,
         value: adbc_core::options::OptionValue,
@@ -275,10 +253,8 @@ impl Optionable for DataFusionConnection {
         match key.as_ref() {
             constants::ADBC_CONNECTION_OPTION_CURRENT_CATALOG => match value {
                 OptionValue::String(value) => {
-                    self.runtime.block_on(async {
-                        let query = format!("SET datafusion.catalog.default_catalog = {value}");
-                        self.ctx.sql(query.as_str()).await.unwrap();
-                    });
+                    let query = format!("SET datafusion.catalog.default_catalog = {value}");
+                    self.ctx.sql(query.as_str()).await.unwrap();
                     Ok(())
                 }
                 _ => Err(Error::with_message_and_status(
@@ -288,10 +264,8 @@ impl Optionable for DataFusionConnection {
             },
             constants::ADBC_CONNECTION_OPTION_CURRENT_DB_SCHEMA => match value {
                 OptionValue::String(value) => {
-                    self.runtime.block_on(async {
-                        let query = format!("SET datafusion.catalog.default_schema = {value}");
-                        self.ctx.sql(query.as_str()).await.unwrap();
-                    });
+                    let query = format!("SET datafusion.catalog.default_schema = {value}");
+                    self.ctx.sql(query.as_str()).await.unwrap();
                     Ok(())
                 }
                 _ => Err(Error::with_message_and_status(
@@ -306,7 +280,7 @@ impl Optionable for DataFusionConnection {
         }
     }
 
-    fn get_option_string(&self, key: Self::Option) -> adbc_core::error::Result<String> {
+    async fn get_option_string(&self, key: Self::Option) -> adbc_core::error::Result<String> {
         match key.as_ref() {
             constants::ADBC_CONNECTION_OPTION_CURRENT_CATALOG => Ok(self
                 .ctx
@@ -329,21 +303,21 @@ impl Optionable for DataFusionConnection {
         }
     }
 
-    fn get_option_bytes(&self, key: Self::Option) -> adbc_core::error::Result<Vec<u8>> {
+    async fn get_option_bytes(&self, key: Self::Option) -> adbc_core::error::Result<Vec<u8>> {
         Err(Error::with_message_and_status(
             format!("Unrecognized option: {key:?}"),
             Status::NotFound,
         ))
     }
 
-    fn get_option_int(&self, key: Self::Option) -> adbc_core::error::Result<i64> {
+    async fn get_option_int(&self, key: Self::Option) -> adbc_core::error::Result<i64> {
         Err(Error::with_message_and_status(
             format!("Unrecognized option: {key:?}"),
             Status::NotFound,
         ))
     }
 
-    fn get_option_double(&self, key: Self::Option) -> adbc_core::error::Result<f64> {
+    async fn get_option_double(&self, key: Self::Option) -> adbc_core::error::Result<f64> {
         Err(Error::with_message_and_status(
             format!("Unrecognized option: {key:?}"),
             Status::NotFound,
@@ -470,16 +444,15 @@ impl GetObjectsBuilder {
         }
     }
 
-    pub fn build(
+    pub async fn build(
         &mut self,
-        runtime: &Runtime,
         ctx: &SessionContext,
         depth: &ObjectDepth,
     ) -> Result<RecordBatch> {
         let mut catalogs = ctx.catalog_names();
         self.catalog_names.append(&mut catalogs);
 
-        self.catalog_names.iter().for_each(|cat| {
+        for cat in &self.catalog_names {
             let catalog_provider = ctx.catalog(cat).unwrap();
             let schema_names = catalog_provider.schema_names();
             self.catalog_db_schema_names
@@ -488,35 +461,33 @@ impl GetObjectsBuilder {
             self.catalog_db_schema_offsets
                 .push(self.catalog_db_schema_offsets.last().unwrap() + schema_names.len() as i32);
 
-            schema_names.iter().for_each(|schema| {
+            for schema in &schema_names {
                 let schema_provider = catalog_provider.schema(schema).unwrap();
                 let table_names = schema_provider.table_names();
                 self.table_names.append(&mut table_names.clone());
                 self.table_offsets
                     .push(self.table_offsets.last().unwrap() + table_names.len() as i32);
 
-                table_names.iter().for_each(|t| {
-                    runtime.block_on(async {
-                        let table_provider = schema_provider.table(t).await.unwrap().unwrap();
-                        let table_type = match table_provider.table_type() {
-                            TableType::Base => "Base",
-                            TableType::View => "View",
-                            TableType::Temporary => "Temporary",
-                        };
-                        self.table_types.push(table_type.to_string());
-
-                        let schema = table_provider.schema();
-                        let num_fields = schema.fields().len();
-
-                        schema.fields().iter().for_each(|f| {
-                            self.column_names.push(f.name().clone());
-                        });
-                        self.column_offsets
-                            .push(self.column_offsets.last().unwrap() + num_fields as i32);
+                for t in &table_names {
+                    let table_provider = schema_provider.table(t).await.unwrap().unwrap();
+                    let table_type = match table_provider.table_type() {
+                        TableType::Base => "Base",
+                        TableType::View => "View",
+                        TableType::Temporary => "Temporary",
+                    };
+                    self.table_types.push(table_type.to_string());
+
+                    let schema = table_provider.schema();
+                    let num_fields = schema.fields().len();
+
+                    schema.fields().iter().for_each(|f| {
+                        self.column_names.push(f.name().clone());
                     });
-                });
-            });
-        });
+                    self.column_offsets
+                        .push(self.column_offsets.last().unwrap() + num_fields as i32);
+                }
+            }
+        }
 
         //////////////////////////////////////////////////////
 
@@ -721,12 +692,11 @@ impl GetObjectsBuilder {
     }
 }
 
-impl Connection for DataFusionConnection {
+impl AsyncConnection for DataFusionConnection {
     type StatementType = DataFusionStatement;
 
-    fn new_statement(&mut self) -> adbc_core::error::Result<Self::StatementType> {
+    async fn new_statement(&mut self) -> adbc_core::error::Result<Self::StatementType> {
         Ok(DataFusionStatement {
-            runtime: self.runtime.clone(),
             ctx: self.ctx.clone(),
             sql_query: None,
             substrait_plan: None,
@@ -735,11 +705,11 @@ impl Connection for DataFusionConnection {
         })
     }
 
-    fn cancel(&mut self) -> adbc_core::error::Result<()> {
+    async fn cancel(&mut self) -> adbc_core::error::Result<()> {
         todo!()
     }
 
-    fn get_info(
+    async fn get_info(
         &self,
         codes: Option<std::collections::HashSet<adbc_core::options::InfoCode>>,
     ) -> Result<impl RecordBatchReader + Send> {
@@ -758,7 +728,7 @@ impl Connection for DataFusionConnection {
         Ok(reader)
     }
 
-    fn get_objects(
+    async fn get_objects(
         &self,
         depth: adbc_core::options::ObjectDepth,
         _catalog: Option<&str>,
@@ -767,12 +737,12 @@ impl Connection for DataFusionConnection {
         _table_type: Option<Vec<&str>>,
         _column_name: Option<&str>,
     ) -> Result<impl RecordBatchReader + Send> {
-        let batch = GetObjectsBuilder::new().build(&self.runtime, &self.ctx, &depth)?;
+        let batch = GetObjectsBuilder::new().build(&self.ctx, &depth).await?;
         let reader = SingleBatchReader::new(batch);
         Ok(reader)
     }
 
-    fn get_table_schema(
+    async fn get_table_schema(
         &self,
         _catalog: Option<&str>,
         _db_schema: Option<&str>,
@@ -781,15 +751,15 @@ impl Connection for DataFusionConnection {
         todo!()
     }
 
-    fn get_table_types(&self) -> Result<SingleBatchReader> {
+    async fn get_table_types(&self) -> Result<SingleBatchReader> {
         todo!()
     }
 
-    fn get_statistic_names(&self) -> Result<SingleBatchReader> {
+    async fn get_statistic_names(&self) -> Result<SingleBatchReader> {
         todo!()
     }
 
-    fn get_statistics(
+    async fn get_statistics(
         &self,
         _catalog: Option<&str>,
         _db_schema: Option<&str>,
@@ -799,21 +769,20 @@ impl Connection for DataFusionConnection {
         todo!()
     }
 
-    fn commit(&mut self) -> adbc_core::error::Result<()> {
+    async fn commit(&mut self) -> adbc_core::error::Result<()> {
         todo!()
     }
 
-    fn rollback(&mut self) -> adbc_core::error::Result<()> {
+    async fn rollback(&mut self) -> adbc_core::error::Result<()> {
         todo!()
     }
 
-    fn read_partition(&self, _partition: impl AsRef<[u8]>) -> Result<SingleBatchReader> {
+    async fn read_partition(&self, _partition: impl AsRef<[u8]>) -> Result<SingleBatchReader> {
         todo!()
     }
 }
 
 pub struct DataFusionStatement {
-    runtime: Arc<Runtime>,
     ctx: Arc<SessionContext>,
     sql_query: Option<String>,
     substrait_plan: Option<Plan>,
@@ -821,10 +790,10 @@ pub struct DataFusionStatement {
     ingest_target_table: Option<String>,
 }
 
-impl Optionable for DataFusionStatement {
+impl AsyncOptionable for DataFusionStatement {
     type Option = OptionStatement;
 
-    fn set_option(
+    async fn set_option(
         &mut self,
         key: Self::Option,
         value: adbc_core::options::OptionValue,
@@ -847,7 +816,7 @@ impl Optionable for DataFusionStatement {
         }
     }
 
-    fn get_option_string(&self, key: Self::Option) -> adbc_core::error::Result<String> {
+    async fn get_option_string(&self, key: Self::Option) -> adbc_core::error::Result<String> {
         match key.as_ref() {
             constants::ADBC_INGEST_OPTION_TARGET_TABLE => {
                 let target_table = self.ingest_target_table.clone();
@@ -866,21 +835,21 @@ impl Optionable for DataFusionStatement {
         }
     }
 
-    fn get_option_bytes(&self, key: Self::Option) -> adbc_core::error::Result<Vec<u8>> {
+    async fn get_option_bytes(&self, key: Self::Option) -> adbc_core::error::Result<Vec<u8>> {
         Err(Error::with_message_and_status(
             format!("Unrecognized option: {key:?}"),
             Status::NotFound,
         ))
     }
 
-    fn get_option_int(&self, key: Self::Option) -> adbc_core::error::Result<i64> {
+    async fn get_option_int(&self, key: Self::Option) -> adbc_core::error::Result<i64> {
         Err(Error::with_message_and_status(
             format!("Unrecognized option: {key:?}"),
             Status::NotFound,
         ))
     }
 
-    fn get_option_double(&self, key: Self::Option) -> adbc_core::error::Result<f64> {
+    async fn get_option_double(&self, key: Self::Option) -> adbc_core::error::Result<f64> {
         Err(Error::with_message_and_status(
             format!("Unrecognized option: {key:?}"),
             Status::NotFound,
@@ -888,104 +857,98 @@ impl Optionable for DataFusionStatement {
     }
 }
 
-impl Statement for DataFusionStatement {
-    fn bind(&mut self, batch: arrow_array::RecordBatch) -> adbc_core::error::Result<()> {
+impl AsyncStatement for DataFusionStatement {
+    async fn bind(&mut self, batch: arrow_array::RecordBatch) -> adbc_core::error::Result<()> {
         self.bound_record_batch.replace(batch);
         Ok(())
     }
 
-    fn bind_stream(
+    async fn bind_stream(
         &mut self,
         _reader: Box<dyn arrow_array::RecordBatchReader + Send>,
     ) -> adbc_core::error::Result<()> {
         todo!()
     }
 
-    fn execute(&mut self) -> Result<impl RecordBatchReader + Send> {
-        self.runtime.block_on(async {
-            let df = if self.sql_query.is_some() {
-                self.ctx
-                    .sql(&self.sql_query.clone().unwrap())
+    async fn execute(&mut self) -> Result<impl RecordBatchReader + Send> {
+        let df = if self.sql_query.is_some() {
+            self.ctx
+                .sql(&self.sql_query.clone().unwrap())
+                .await
+                .unwrap()
+        } else {
+            let plan =
+                from_substrait_plan(&self.ctx.state(), &self.substrait_plan.clone().unwrap())
                     .await
-                    .unwrap()
-            } else {
-                let plan =
-                    from_substrait_plan(&self.ctx.state(), &self.substrait_plan.clone().unwrap())
-                        .await
-                        .unwrap();
-                self.ctx.execute_logical_plan(plan).await.unwrap()
-            };
+                    .unwrap();
+            self.ctx.execute_logical_plan(plan).await.unwrap()
+        };
 
-            Ok(DataFusionReader::new(df).await)
-        })
+        Ok(DataFusionReader::new(df).await)
     }
 
-    fn execute_update(&mut self) -> adbc_core::error::Result<Option<i64>> {
+    async fn execute_update(&mut self) -> adbc_core::error::Result<Option<i64>> {
         if self.sql_query.is_some() {
-            self.runtime.block_on(async {
-                let _ = self
-                    .ctx
-                    .sql(&self.sql_query.clone().unwrap())
-                    .await
-                    .unwrap();
-            });
+            let _ = self
+                .ctx
+                .sql(&self.sql_query.clone().unwrap())
+                .await
+                .unwrap();
         } else if let Some(batch) = self.bound_record_batch.take() {
-            self.runtime.block_on(async {
-                let table = match self.ingest_target_table.clone() {
-                    Some(table) => table,
-                    None => todo!(),
-                };
-
-                self.ctx
-                    .read_batch(batch)
-                    .unwrap()
-                    .write_table(table.as_str(), DataFrameWriteOptions::new())
-                    .await
-                    .unwrap();
-            });
+            let table = match self.ingest_target_table.clone() {
+                Some(table) => table,
+                None => todo!(),
+            };
+
+            self.ctx
+                .read_batch(batch)
+                .unwrap()
+                .write_table(table.as_str(), DataFrameWriteOptions::new())
+                .await
+                .unwrap();
         }
 
         Ok(Some(0))
     }
 
-    fn execute_schema(&mut self) -> adbc_core::error::Result<arrow_schema::Schema> {
-        self.runtime.block_on(async {
-            let df = self
-                .ctx
-                .sql(&self.sql_query.clone().unwrap())
-                .await
-                .unwrap();
+    async fn execute_schema(&mut self) -> adbc_core::error::Result<arrow_schema::Schema> {
+        let df = self
+            .ctx
+            .sql(&self.sql_query.clone().unwrap())
+            .await
+            .unwrap();
 
-            Ok(df.schema().as_arrow().clone())
-        })
+        Ok(df.schema().as_arrow().clone())
     }
 
-    fn execute_partitions(&mut self) -> adbc_core::error::Result<adbc_core::PartitionedResult> {
+    async fn execute_partitions(
+        &mut self,
+    ) -> adbc_core::error::Result<adbc_core::PartitionedResult> {
         todo!()
     }
 
-    fn get_parameter_schema(&self) -> adbc_core::error::Result<arrow_schema::Schema> {
+    async fn get_parameter_schema(&self) -> adbc_core::error::Result<arrow_schema::Schema> {
         todo!()
     }
 
-    fn prepare(&mut self) -> adbc_core::error::Result<()> {
+    async fn prepare(&mut self) -> adbc_core::error::Result<()> {
         todo!()
     }
 
-    fn set_sql_query(&mut self, query: impl AsRef<str>) -> adbc_core::error::Result<()> {
+    async fn set_sql_query(&mut self, query: impl AsRef<str>) -> adbc_core::error::Result<()> {
         self.sql_query = Some(query.as_ref().to_string());
         Ok(())
     }
 
-    fn set_substrait_plan(&mut self, plan: impl AsRef<[u8]>) -> adbc_core::error::Result<()> {
+    async fn set_substrait_plan(&mut self, plan: impl AsRef<[u8]>) -> adbc_core::error::Result<()> {
         self.substrait_plan = Some(Plan::decode(plan.as_ref()).unwrap());
         Ok(())
     }
 
-    fn cancel(&mut self) -> adbc_core::error::Result<()> {
+    async fn cancel(&mut self) -> adbc_core::error::Result<()> {
         todo!()
     }
 }
 
 #[cfg(feature = "ffi")]
-adbc_ffi::export_driver!(DataFusionDriverInit, DataFusionDriver);
+adbc_ffi::export_driver!(DataFusionDriverInit, crate::syncify::SyncDataFusionDriver);
diff --git a/rust/driver/datafusion/src/syncify.rs b/rust/driver/datafusion/src/syncify.rs
new file mode 100644
index 0000000000..527754e865
--- /dev/null
+++ b/rust/driver/datafusion/src/syncify.rs
@@ -0,0 +1,338 @@
+#![allow(dead_code)]
+use std::sync::Arc;
+
+use adbc_core::{
+    non_blocking::{AsyncConnection, AsyncDatabase, AsyncDriver, AsyncOptionable, AsyncStatement},
+    options::{OptionConnection, OptionDatabase, OptionStatement},
+    Connection, Database, Driver, Optionable, Statement,
+};
+use tokio::runtime::Runtime;
+
+use crate::{DataFusionConnection, DataFusionDatabase, DataFusionDriver, DataFusionStatement};
+
+pub struct SyncDataFusionDriver {
+    driver: DataFusionDriver,
+    rt: Arc<Runtime>,
+}
+
+pub struct SyncDataFusionDatabase {
+    db: DataFusionDatabase,
+    rt: Arc<Runtime>,
+}
+
+pub struct SyncDataFusionConnection {
+    conn: DataFusionConnection,
+    rt: Arc<Runtime>,
+}
+
+pub struct SyncDataFusionStatement {
+    stmt: DataFusionStatement,
+    rt: Arc<Runtime>,
+}
+
+impl Default for SyncDataFusionDriver {
+    fn default() -> Self {
+        Self {
+            driver: Default::default(),
+            rt: Arc::new(
+                tokio::runtime::Builder::new_multi_thread()
+                    .enable_all()
+                    .build()
+                    .unwrap(),
+            ),
+        }
+    }
+}
+
+impl Driver for SyncDataFusionDriver {
+    type DatabaseType = SyncDataFusionDatabase;
+
+    fn new_database(&mut self) -> adbc_core::error::Result<Self::DatabaseType> {
+        let db = self.rt.block_on(self.driver.new_database())?;
+
+        Ok(SyncDataFusionDatabase {
+            db,
+            rt: self.rt.clone(),
+        })
+    }
+
+    fn new_database_with_opts(
+        &mut self,
+        opts: impl IntoIterator<
+            Item = (
+                adbc_core::options::OptionDatabase,
+                adbc_core::options::OptionValue,
+            ),
+        >,
+    ) -> adbc_core::error::Result<Self::DatabaseType> {
+        let db = self.rt.block_on(
+            self.driver
+                .new_database_with_opts(opts.into_iter().collect()),
+        )?;
+
+        Ok(SyncDataFusionDatabase {
+            db,
+            rt: self.rt.clone(),
+        })
+    }
+}
+
+impl Optionable for SyncDataFusionDatabase {
+    type Option = OptionDatabase;
+
+    fn set_option(
+        &mut self,
+        key: Self::Option,
+        value: adbc_core::options::OptionValue,
+    ) -> adbc_core::error::Result<()> {
+        self.rt.block_on(self.db.set_option(key, value))
+    }
+
+    fn get_option_string(&self, key: Self::Option) -> adbc_core::error::Result<String> {
+        self.rt.block_on(self.db.get_option_string(key))
+    }
+
+    fn get_option_bytes(&self, key: Self::Option) -> adbc_core::error::Result<Vec<u8>> {
+        self.rt.block_on(self.db.get_option_bytes(key))
+    }
+
+    fn get_option_int(&self, key: Self::Option) -> adbc_core::error::Result<i64> {
+        self.rt.block_on(self.db.get_option_int(key))
+    }
+
+    fn get_option_double(&self, key: Self::Option) -> adbc_core::error::Result<f64> {
+        self.rt.block_on(self.db.get_option_double(key))
+    }
+}
+
+impl Database for SyncDataFusionDatabase {
+    type ConnectionType = SyncDataFusionConnection;
+
+    fn new_connection(&self) -> adbc_core::error::Result<Self::ConnectionType> {
+        let conn = self.rt.block_on(self.db.new_connection())?;
+
+        Ok(SyncDataFusionConnection {
+            conn,
+            rt: self.rt.clone(),
+        })
+    }
+
+    fn new_connection_with_opts(
+        &self,
+        opts: impl IntoIterator<
+            Item = (
+                adbc_core::options::OptionConnection,
+                adbc_core::options::OptionValue,
+            ),
+        >,
+    ) -> adbc_core::error::Result<Self::ConnectionType> {
+        let conn = self
+            .rt
+            .block_on(self.db.new_connection_with_opts(opts.into_iter().collect()))?;
+
+        Ok(SyncDataFusionConnection {
+            conn,
+            rt: self.rt.clone(),
+        })
+    }
+}
+
+impl Optionable for SyncDataFusionConnection {
+    type Option = OptionConnection;
+
+    fn set_option(
+        &mut self,
+        key: Self::Option,
+        value: adbc_core::options::OptionValue,
+    ) -> adbc_core::error::Result<()> {
+        self.rt.block_on(self.conn.set_option(key, value))
+    }
+
+    fn get_option_string(&self, key: Self::Option) -> adbc_core::error::Result<String> {
+        self.rt.block_on(self.conn.get_option_string(key))
+    }
+
+    fn get_option_bytes(&self, key: Self::Option) -> adbc_core::error::Result<Vec<u8>> {
+        self.rt.block_on(self.conn.get_option_bytes(key))
+    }
+
+    fn get_option_int(&self, key: Self::Option) -> adbc_core::error::Result<i64> {
+        self.rt.block_on(self.conn.get_option_int(key))
+    }
+
+    fn get_option_double(&self, key: Self::Option) -> adbc_core::error::Result<f64> {
+        self.rt.block_on(self.conn.get_option_double(key))
+    }
+}
+
+impl Connection for SyncDataFusionConnection {
+    type StatementType = SyncDataFusionStatement;
+
+    fn new_statement(&mut self) -> adbc_core::error::Result<Self::StatementType> {
+        let stmt = self.rt.block_on(self.conn.new_statement())?;
+
+        Ok(SyncDataFusionStatement {
+            stmt,
+            rt: self.rt.clone(),
+        })
+    }
+
+    fn cancel(&mut self) -> adbc_core::error::Result<()> {
+        self.rt.block_on(self.conn.cancel())
+    }
+
+    fn get_info(
+        &self,
+        codes: Option<std::collections::HashSet<adbc_core::options::InfoCode>>,
+    ) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
+        self.rt.block_on(self.conn.get_info(codes))
+    }
+
+    fn get_objects(
+        &self,
+        depth: adbc_core::options::ObjectDepth,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        table_type: Option<Vec<&str>>,
+        column_name: Option<&str>,
+    ) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
+        self.rt.block_on(self.conn.get_objects(
+            depth,
+            catalog,
+            db_schema,
+            table_name,
+            table_type,
+            column_name,
+        ))
+    }
+
+    fn get_table_schema(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: &str,
+    ) -> adbc_core::error::Result<arrow_schema::Schema> {
+        self.rt
+            .block_on(self.conn.get_table_schema(catalog, db_schema, table_name))
+    }
+
+    fn get_table_types(
+        &self,
+    ) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
+        self.rt.block_on(self.conn.get_table_types())
+    }
+
+    fn get_statistic_names(
+        &self,
+    ) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
+        self.rt.block_on(self.conn.get_statistic_names())
+    }
+
+    fn get_statistics(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        approximate: bool,
+    ) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
+        self.rt.block_on(
+            self.conn
+                .get_statistics(catalog, db_schema, table_name, approximate),
+        )
+    }
+
+    fn commit(&mut self) -> adbc_core::error::Result<()> {
+        self.rt.block_on(self.conn.commit())
+    }
+
+    fn rollback(&mut self) -> adbc_core::error::Result<()> {
+        self.rt.block_on(self.conn.rollback())
+    }
+
+    fn read_partition(
+        &self,
+        partition: impl AsRef<[u8]>,
+    ) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
+        self.rt
+            .block_on(self.conn.read_partition(partition.as_ref()))
+    }
+}
+
+impl Optionable for SyncDataFusionStatement {
+    type Option = OptionStatement;
+
+    fn set_option(
+        &mut self,
+        key: Self::Option,
+        value: adbc_core::options::OptionValue,
+    ) -> adbc_core::error::Result<()> {
+        self.rt.block_on(self.stmt.set_option(key, value))
+    }
+
+    fn get_option_string(&self, key: Self::Option) -> adbc_core::error::Result<String> {
+        self.rt.block_on(self.stmt.get_option_string(key))
+    }
+
+    fn get_option_bytes(&self, key: Self::Option) -> adbc_core::error::Result<Vec<u8>> {
+        self.rt.block_on(self.stmt.get_option_bytes(key))
+    }
+
+    fn get_option_int(&self, key: Self::Option) -> adbc_core::error::Result<i64> {
+        self.rt.block_on(self.stmt.get_option_int(key))
+    }
+
+    fn get_option_double(&self, key: Self::Option) -> adbc_core::error::Result<f64> {
+        self.rt.block_on(self.stmt.get_option_double(key))
+    }
+}
+
+impl Statement for SyncDataFusionStatement {
+    fn bind(&mut self, batch: arrow_array::RecordBatch) -> adbc_core::error::Result<()> {
+        self.rt.block_on(self.stmt.bind(batch))
+    }
+
+    fn bind_stream(
+        &mut self,
+        reader: Box<dyn arrow_array::RecordBatchReader + Send>,
+    ) -> adbc_core::error::Result<()> {
+        self.rt.block_on(self.stmt.bind_stream(reader))
+    }
+
+    fn execute(&mut self) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
+        self.rt.block_on(self.stmt.execute())
+    }
+
+    fn execute_update(&mut self) -> adbc_core::error::Result<Option<i64>> {
+        self.rt.block_on(self.stmt.execute_update())
+    }
+
+    fn execute_schema(&mut self) -> adbc_core::error::Result<arrow_schema::Schema> {
+        self.rt.block_on(self.stmt.execute_schema())
+    }
+
+    fn execute_partitions(&mut self) -> adbc_core::error::Result<adbc_core::PartitionedResult> {
+        self.rt.block_on(self.stmt.execute_partitions())
+    }
+
+    fn get_parameter_schema(&self) -> adbc_core::error::Result<arrow_schema::Schema> {
+        self.rt.block_on(self.stmt.get_parameter_schema())
+    }
+
+    fn prepare(&mut self) -> adbc_core::error::Result<()> {
+        self.rt.block_on(self.stmt.prepare())
+    }
+
+    fn set_sql_query(&mut self, query: impl AsRef<str>) -> adbc_core::error::Result<()> {
+        self.rt.block_on(self.stmt.set_sql_query(query.as_ref()))
+    }
+
+    fn set_substrait_plan(&mut self, plan: impl AsRef<[u8]>) -> adbc_core::error::Result<()> {
+        self.rt
+            .block_on(self.stmt.set_substrait_plan(plan.as_ref()))
+    }
+
+    fn cancel(&mut self) -> adbc_core::error::Result<()> {
+        self.rt.block_on(self.stmt.cancel())
+    }
+}
diff --git a/rust/driver/datafusion/tests/test_datafusion.rs b/rust/driver/datafusion/tests/test_datafusion.rs
index 9123a480a9..0b27a170ff 100644
--- a/rust/driver/datafusion/tests/test_datafusion.rs
+++ b/rust/driver/datafusion/tests/test_datafusion.rs
@@ -15,7 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use adbc_core::{Connection, Database, Driver, Optionable, Statement};
+use adbc_core::non_blocking::{
+    AsyncConnection, AsyncDatabase, AsyncDriver, AsyncOptionable, AsyncStatement,
+};
 use adbc_datafusion::{DataFusionConnection, DataFusionDriver};
 use arrow_array::RecordBatch;
 use datafusion::prelude::*;
@@ -26,21 +28,23 @@ use datafusion_substrait::logical_plan::producer::to_substrait_plan;
 use datafusion_substrait::substrait::proto::Plan;
 use prost::Message;
 
-fn get_connection(handle: Option<tokio::runtime::Handle>) -> DataFusionConnection {
-    let mut driver = DataFusionDriver::new(handle);
-    let database = driver.new_database().unwrap();
-    database.new_connection().unwrap()
+async fn get_connection() -> DataFusionConnection {
+    let mut driver = DataFusionDriver::default();
+    let database = driver.new_database().await.unwrap();
+    database.new_connection().await.unwrap()
 }
 
-fn get_objects(connection: &DataFusionConnection) -> RecordBatch {
-    let objects = connection.get_objects(
-        adbc_core::options::ObjectDepth::All,
-        None,
-        None,
-        None,
-        None,
-        None,
-    );
+async fn get_objects(connection: &DataFusionConnection) -> RecordBatch {
+    let objects = connection
+        .get_objects(
+            adbc_core::options::ObjectDepth::All,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )
+        .await;
 
     let batches: Vec<RecordBatch> = objects.unwrap().map(|b| b.unwrap()).collect();
 
@@ -49,151 +53,167 @@ fn get_objects(connection: &DataFusionConnection) -> RecordBatch {
     concat_batches(&schema, &batches).unwrap()
 }
 
-fn execute_update(connection: &mut DataFusionConnection, query: &str) {
-    let mut statement = connection.new_statement().unwrap();
-    let _ = statement.set_sql_query(query);
-    let _ = statement.execute_update();
+async fn execute_update(connection: &mut DataFusionConnection, query: &str) {
+    let mut statement = connection.new_statement().await.unwrap();
+    let _ = statement.set_sql_query(query).await;
+    let _ = statement.execute_update().await;
 }
 
-fn execute_sql_query(connection: &mut DataFusionConnection, query: &str) -> RecordBatch {
-    let mut statement = connection.new_statement().unwrap();
-    let _ = statement.set_sql_query(query);
+async fn execute_sql_query(connection: &mut DataFusionConnection, query: &str) -> RecordBatch {
+    let mut statement = connection.new_statement().await.unwrap();
+    let _ = statement.set_sql_query(query).await;
 
-    let batches: Vec<RecordBatch> = statement.execute().unwrap().map(|b| b.unwrap()).collect();
+    let batches: Vec<RecordBatch> = statement
+        .execute()
+        .await
+        .unwrap()
+        .map(|b| b.unwrap())
+        .collect();
 
     let schema = batches.first().unwrap().schema();
 
     concat_batches(&schema, &batches).unwrap()
 }
 
-fn execute_substrait(connection: &mut DataFusionConnection, plan: Plan) -> RecordBatch {
-    let mut statement = connection.new_statement().unwrap();
+async fn execute_substrait(connection: &mut DataFusionConnection, plan: Plan) -> RecordBatch {
+    let mut statement = connection.new_statement().await.unwrap();
 
-    let _ = statement.set_substrait_plan(plan.encode_to_vec());
+    let _ = statement.set_substrait_plan(plan.encode_to_vec()).await;
 
-    let batches: Vec<RecordBatch> = statement.execute().unwrap().map(|b| b.unwrap()).collect();
+    let batches: Vec<RecordBatch> = statement
+        .execute()
+        .await
+        .unwrap()
+        .map(|b| b.unwrap())
+        .collect();
 
     let schema = batches.first().unwrap().schema();
 
     concat_batches(&schema, &batches).unwrap()
 }
 
-#[test]
-fn test_connection_options() {
-    let mut connection = get_connection(None);
+#[tokio::test]
+async fn test_connection_options() {
+    let mut connection = get_connection().await;
 
     let current_catalog = connection
         .get_option_string(OptionConnection::CurrentCatalog)
+        .await
         .unwrap();
 
     assert_eq!(current_catalog, "datafusion");
 
-    let _ = connection.set_option(
-        OptionConnection::CurrentCatalog,
-        OptionValue::String("datafusion2".to_string()),
-    );
+    let _ = connection
+        .set_option(
+            OptionConnection::CurrentCatalog,
+            OptionValue::String("datafusion2".to_string()),
+        )
+        .await;
 
     let current_catalog = connection
         .get_option_string(OptionConnection::CurrentCatalog)
+        .await
         .unwrap();
 
     assert_eq!(current_catalog, "datafusion2");
 
     let current_schema = connection
         .get_option_string(OptionConnection::CurrentSchema)
+        .await
         .unwrap();
 
     assert_eq!(current_schema, "public");
 
-    let _ = connection.set_option(
-        OptionConnection::CurrentSchema,
-        OptionValue::String("public2".to_string()),
-    );
+    let _ = connection
+        .set_option(
+            OptionConnection::CurrentSchema,
+            OptionValue::String("public2".to_string()),
+        )
+        .await;
 
     let current_schema = connection
         .get_option_string(OptionConnection::CurrentSchema)
+        .await
         .unwrap();
 
     assert_eq!(current_schema, "public2");
 }
 
-#[test]
-fn test_get_objects_database() {
-    let mut connection = get_connection(None);
+#[tokio::test]
+async fn test_get_objects_database() {
+    let mut connection = get_connection().await;
 
-    let objects = get_objects(&connection);
+    let objects = get_objects(&connection).await;
 
     assert_eq!(objects.num_rows(), 1);
 
-    execute_update(&mut connection, "CREATE DATABASE another");
+    execute_update(&mut connection, "CREATE DATABASE another").await;
 
-    let objects = get_objects(&connection);
+    let objects = get_objects(&connection).await;
 
     assert_eq!(objects.num_rows(), 2);
 }
 
-#[test]
-fn test_execute_sql() {
-    let mut connection = get_connection(None);
+#[tokio::test]
+async fn test_execute_sql() {
+    let mut connection = get_connection().await;
 
-    execute_update(&mut connection, "CREATE TABLE IF NOT EXISTS datafusion.public.example (c1 INT, c2 VARCHAR) AS VALUES(1,'HELLO'),(2,'DATAFUSION'),(3,'!')");
+    execute_update(&mut connection, "CREATE TABLE IF NOT EXISTS datafusion.public.example (c1 INT, c2 VARCHAR) AS VALUES(1,'HELLO'),(2,'DATAFUSION'),(3,'!')").await;
 
-    let batch = execute_sql_query(&mut connection, "SELECT * FROM datafusion.public.example");
+    let batch = execute_sql_query(&mut connection, "SELECT * FROM datafusion.public.example").await;
 
     assert_eq!(batch.num_rows(), 3);
     assert_eq!(batch.num_columns(), 2);
 }
 
-#[test]
-fn test_ingest() {
-    let mut connection = get_connection(None);
+#[tokio::test]
+async fn test_ingest() {
+    let mut connection = get_connection().await;
 
-    execute_update(&mut connection, "CREATE TABLE IF NOT EXISTS datafusion.public.example (c1 INT, c2 VARCHAR) AS VALUES(1,'HELLO'),(2,'DATAFUSION'),(3,'!')");
+    execute_update(&mut connection, "CREATE TABLE IF NOT EXISTS datafusion.public.example (c1 INT, c2 VARCHAR) AS VALUES(1,'HELLO'),(2,'DATAFUSION'),(3,'!')").await;
 
-    let batch = execute_sql_query(&mut connection, "SELECT * FROM datafusion.public.example");
+    let batch = execute_sql_query(&mut connection, "SELECT * FROM datafusion.public.example").await;
 
     assert_eq!(batch.num_rows(), 3);
     assert_eq!(batch.num_columns(), 2);
 
-    let mut statement = connection.new_statement().unwrap();
+    let mut statement = connection.new_statement().await.unwrap();
 
-    let _ = statement.set_option(
-        OptionStatement::TargetTable,
-        OptionValue::String("example".to_string()),
-    );
-    let _ = statement.bind(batch);
+    let _ = statement
+        .set_option(
+            OptionStatement::TargetTable,
+            OptionValue::String("example".to_string()),
+        )
+        .await;
+    let _ = statement.bind(batch).await;
 
-    let _ = statement.execute_update();
+    let _ = statement.execute_update().await;
 
-    let batch = execute_sql_query(&mut connection, "SELECT * FROM datafusion.public.example");
+    let batch = execute_sql_query(&mut connection, "SELECT * FROM datafusion.public.example").await;
 
     assert_eq!(batch.num_rows(), 6);
 }
 
-#[test]
-fn test_execute_substrait() {
-    let mut connection = get_connection(None);
+#[tokio::test]
+async fn test_execute_substrait() {
+    let mut connection = get_connection().await;
 
-    execute_update(&mut connection, "CREATE TABLE IF NOT EXISTS datafusion.public.example (c1 INT, c2 VARCHAR) AS VALUES(1,'HELLO'),(2,'DATAFUSION'),(3,'!')");
+    execute_update(&mut connection, "CREATE TABLE IF NOT EXISTS datafusion.public.example (c1 INT, c2 VARCHAR) AS VALUES(1,'HELLO'),(2,'DATAFUSION'),(3,'!')").await;
 
     let ctx = SessionContext::new();
 
-    let runtime = tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()
-        .unwrap();
-
-    let plan = runtime.block_on(async {
-        let _ = ctx.sql(
-            "CREATE TABLE IF NOT EXISTS datafusion.public.example (c1 INT, c2 VARCHAR) AS VALUES(1,'HELLO'),(2,'DATAFUSION'),(3,'!')"
-        ).await;
+    let _ = ctx.sql(
+        "CREATE TABLE IF NOT EXISTS datafusion.public.example (c1 INT, c2 VARCHAR) AS VALUES(1,'HELLO'),(2,'DATAFUSION'),(3,'!')"
+    ).await;
 
-        let df = ctx.sql("SELECT c1, c2 FROM datafusion.public.example").await.unwrap();
+    let df = ctx
+        .sql("SELECT c1, c2 FROM datafusion.public.example")
+        .await
+        .unwrap();
 
-        to_substrait_plan(df.logical_plan(), &ctx.state()).unwrap()
-    });
+    let plan = to_substrait_plan(df.logical_plan(), &ctx.state()).unwrap();
 
-    let batch = execute_substrait(&mut connection, *plan);
+    let batch = execute_substrait(&mut connection, *plan).await;
 
     assert_eq!(batch.num_rows(), 3);
     assert_eq!(batch.num_columns(), 2);
@@ -201,11 +221,11 @@ fn test_execute_substrait() {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_running_in_async() {
-    let mut connection = get_connection(Some(tokio::runtime::Handle::current()));
+    let mut connection = get_connection().await;
 
-    execute_update(&mut connection, "CREATE TABLE IF NOT EXISTS datafusion.public.example (c1 INT, c2 VARCHAR) AS VALUES(1,'HELLO'),(2,'DATAFUSION'),(3,'!')");
+    execute_update(&mut connection, "CREATE TABLE IF NOT EXISTS datafusion.public.example (c1 INT, c2 VARCHAR) AS VALUES(1,'HELLO'),(2,'DATAFUSION'),(3,'!')").await;
 
-    let batch = execute_sql_query(&mut connection, "SELECT * FROM datafusion.public.example");
+    let batch = execute_sql_query(&mut connection, "SELECT * FROM datafusion.public.example").await;
 
     assert_eq!(batch.num_rows(), 3);
     assert_eq!(batch.num_columns(), 2);

From ce0a3803aed2e2aaa82d251617a44f3f694f1023 Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Fri, 14 Nov 2025 11:24:21 +0300
Subject: [PATCH 02/14] add: license for new files

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/core/src/non_blocking.rs         | 17 +++++++++++++++++
 rust/driver/datafusion/src/syncify.rs | 16 ++++++++++++++++
 2 files changed, 33 insertions(+)

diff --git a/rust/core/src/non_blocking.rs b/rust/core/src/non_blocking.rs
index 96683cc9af..0a34a24442 100644
--- a/rust/core/src/non_blocking.rs
+++ b/rust/core/src/non_blocking.rs
@@ -1,3 +1,20 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
 use arrow_array::{RecordBatch, RecordBatchReader};
 use arrow_schema::Schema;
 
diff --git a/rust/driver/datafusion/src/syncify.rs b/rust/driver/datafusion/src/syncify.rs
index 527754e865..d63bc3fc9b 100644
--- a/rust/driver/datafusion/src/syncify.rs
+++ b/rust/driver/datafusion/src/syncify.rs
@@ -1,3 +1,19 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
 #![allow(dead_code)]
 use std::sync::Arc;
 

From 91a59bc2fcae67c362928bd66d444f2c4f907898 Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Fri, 14 Nov 2025 13:47:11 +0300
Subject: [PATCH 03/14] fix: docs for async traits

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/core/src/non_blocking.rs | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/rust/core/src/non_blocking.rs b/rust/core/src/non_blocking.rs
index 0a34a24442..35e6b8c6ee 100644
--- a/rust/core/src/non_blocking.rs
+++ b/rust/core/src/non_blocking.rs
@@ -148,7 +148,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
     ///   filter by name. May be a search pattern.
     /// - `table_type` - Only show tables matching one of the given table
     ///   types. If `None`, show tables of any type. Valid table types can be fetched
-    ///   from [Connection::get_table_types].
+    ///   from [AsyncConnection::get_table_types].
     /// - `column_name` - Only show columns with the given name. If
     ///   `None`, do not filter by name.  May be a search pattern..
     ///
@@ -326,7 +326,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
     ///    dictionary type). Values in [0, 1024) are reserved for ADBC.  Other
     ///    values are for implementation-specific statistics.  For the definitions
     ///    of predefined statistic types, see [options::Statistics]. To get
-    ///    driver-specific statistic names, use [Connection::get_statistic_names].
+    ///    driver-specific statistic names, use [AsyncConnection::get_statistic_names].
     /// 3. If true, then the value is approximate or best-effort.
     ///
     /// VALUE_SCHEMA is a dense union with members:
@@ -361,7 +361,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
 
     /// Retrieve a given partition of data.
     ///
-    /// A partition can be retrieved from [Statement::execute_partitions].
+    /// A partition can be retrieved from [AsyncStatement::execute_partitions].
     ///
     /// # Arguments
     ///
@@ -426,7 +426,7 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> {
     /// This invalidates any prior result sets.
     ///
     /// Depending on the driver, this may require first executing
-    /// [Statement::prepare].
+    /// [AsyncStatement::prepare].
     ///
     /// # Since
     ///
@@ -448,7 +448,7 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> {
     /// be an empty string. If the type cannot be determined, the type of
     /// the corresponding field will be NA (NullType).
     ///
-    /// This should be called after [Statement::prepare].
+    /// This should be called after [AsyncStatement::prepare].
     fn get_parameter_schema(&self) -> impl Future<Output = Result<Schema>> + Send;
 
     /// Turn this statement into a prepared statement to be executed multiple
@@ -459,8 +459,8 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> {
 
     /// Set the SQL query to execute.
     ///
-    /// The query can then be executed with [Statement::execute]. For queries
-    /// expected to be executed repeatedly, call [Statement::prepare] first.
+    /// The query can then be executed with [AsyncStatement::execute]. For queries
+    /// expected to be executed repeatedly, call [AsyncStatement::prepare] first.
     fn set_sql_query(
         &mut self,
         query: impl AsRef<str> + Send,
@@ -468,8 +468,8 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> {
 
     /// Set the Substrait plan to execute.
     ///
-    /// The query can then be executed with [Statement::execute]. For queries
-    /// expected to be executed repeatedly, call [Statement::prepare] first.
+    /// The query can then be executed with [AsyncStatement::execute]. For queries
+    /// expected to be executed repeatedly, call [AsyncStatement::prepare] first.
     fn set_substrait_plan(
         &mut self,
         plan: impl AsRef<[u8]> + Send,
@@ -477,7 +477,7 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> {
 
     /// Cancel execution of an in-progress query.
     ///
-    /// This can be called during [Statement::execute] (or similar), or while
+    /// This can be called during [AsyncStatement::execute] (or similar), or while
     /// consuming a result set returned from such.
     ///
     /// # Since

From 4389ece2454feea48f7a0837dc4cbcd29fde5751 Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Fri, 14 Nov 2025 15:02:45 +0300
Subject: [PATCH 04/14] add: trait-variant for Send bound

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/Cargo.lock                               |  14 ++-
 rust/Cargo.toml                               |   1 +
 rust/core/Cargo.toml                          |   1 +
 rust/core/src/non_blocking.rs                 | 117 ++++++++----------
 rust/driver/datafusion/src/lib.rs             |  18 +--
 rust/driver/datafusion/src/syncify.rs         |   4 +-
 .../datafusion/tests/test_datafusion.rs       |  15 ++-
 7 files changed, 91 insertions(+), 79 deletions(-)

diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index e8070b5dc3..734d87f49c 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -8,6 +8,7 @@ version = "0.22.0"
 dependencies = [
  "arrow-array",
  "arrow-schema",
+ "trait-variant",
 ]
 
 [[package]]
@@ -40,7 +41,7 @@ dependencies = [
  "tempfile",
  "toml",
  "windows-registry",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -2664,6 +2665,17 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "trait-variant"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70977707304198400eb4835a78f6a9f928bf41bba420deb8fdb175cd965d77a7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "twox-hash"
 version = "2.1.1"
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index 644769716d..957aa1f2d7 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -43,3 +43,4 @@ arrow-array = { version = ">=53.1.0, <58", default-features = false, features =
 arrow-buffer = { version = ">=53.1.0, <58", default-features = false }
 arrow-schema = { version = ">=53.1.0, <58", default-features = false }
 arrow-select = { version = ">=53.1.0, <58", default-features = false }
+trait-variant = { version = "0.1.2" }
diff --git a/rust/core/Cargo.toml b/rust/core/Cargo.toml
index bd33bf57f5..b7ce3cc28f 100644
--- a/rust/core/Cargo.toml
+++ b/rust/core/Cargo.toml
@@ -36,6 +36,7 @@ default = []
 [dependencies]
 arrow-array.workspace = true
 arrow-schema.workspace = true
+trait-variant.workspace = true
 
 [package.metadata.docs.rs]
 all-features = true
diff --git a/rust/core/src/non_blocking.rs b/rust/core/src/non_blocking.rs
index 35e6b8c6ee..ff841707a7 100644
--- a/rust/core/src/non_blocking.rs
+++ b/rust/core/src/non_blocking.rs
@@ -19,48 +19,45 @@ use arrow_array::{RecordBatch, RecordBatchReader};
 use arrow_schema::Schema;
 
 use std::collections::HashSet;
-use std::future::Future;
 
 use crate::error::Result;
 use crate::options::{self, *};
 use crate::PartitionedResult;
 
 /// Ability to configure an object by setting/getting options.
-pub trait AsyncOptionable {
-    type Option: AsRef<str> + Send;
+#[trait_variant::make(AsyncOptionable: Send)]
+pub trait LocalAsyncOptionable {
+    type Option: AsRef<str>;
 
     /// Set a post-init option.
-    fn set_option(
-        &mut self,
-        key: Self::Option,
-        value: OptionValue,
-    ) -> impl Future<Output = Result<()>> + Send;
+    async fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()>;
 
     /// Get a string option value by key.
-    fn get_option_string(&self, key: Self::Option) -> impl Future<Output = Result<String>>;
+    async fn get_option_string(&self, key: Self::Option) -> Result<String>;
 
     /// Get a bytes option value by key.
-    fn get_option_bytes(&self, key: Self::Option) -> impl Future<Output = Result<Vec<u8>>>;
+    async fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>>;
 
     /// Get an integer option value by key.
-    fn get_option_int(&self, key: Self::Option) -> impl Future<Output = Result<i64>>;
+    async fn get_option_int(&self, key: Self::Option) -> Result<i64>;
 
     /// Get a float option value by key.
-    fn get_option_double(&self, key: Self::Option) -> impl Future<Output = Result<f64>>;
+    async fn get_option_double(&self, key: Self::Option) -> Result<f64>;
 }
 
 /// A handle to an async ADBC driver.
-pub trait AsyncDriver {
-    type DatabaseType: AsyncDatabase + Send;
+#[trait_variant::make(AsyncDriver: Send)]
+pub trait LocalAsyncDriver {
+    type DatabaseType: LocalAsyncDatabase;
 
     /// Allocate and initialize a new database without pre-init options.
-    fn new_database(&mut self) -> impl Future<Output = Result<Self::DatabaseType>> + Send;
+    async fn new_database(&mut self) -> Result<Self::DatabaseType>;
 
     /// Allocate and initialize a new database with pre-init options.
-    fn new_database_with_opts(
+    async fn new_database_with_opts(
         &mut self,
         opts: Vec<(options::OptionDatabase, OptionValue)>,
-    ) -> impl Future<Output = Result<Self::DatabaseType>> + Send;
+    ) -> Result<Self::DatabaseType>;
 }
 
 /// A handle to an async ADBC database.
@@ -70,17 +67,18 @@ pub trait AsyncDriver {
 /// hold ownership of the in-memory database.
 ///
 /// Databases must be kept alive as long as any connections exist.
-pub trait AsyncDatabase: AsyncOptionable<Option = OptionDatabase> {
-    type ConnectionType: AsyncConnection + Send;
+#[trait_variant::make(AsyncDatabase: Send)]
+pub trait LocalAsyncDatabase: LocalAsyncOptionable<Option = OptionDatabase> {
+    type ConnectionType: LocalAsyncConnection + Send;
 
     /// Allocate and initialize a new connection without pre-init options.
-    fn new_connection(&self) -> impl Future<Output = Result<Self::ConnectionType>> + Send;
+    async fn new_connection(&self) -> Result<Self::ConnectionType>;
 
     /// Allocate and initialize a new connection with pre-init options.
-    fn new_connection_with_opts(
+    async fn new_connection_with_opts(
         &self,
         opts: Vec<(options::OptionConnection, OptionValue)>,
-    ) -> impl Future<Output = Result<Self::ConnectionType>> + Send;
+    ) -> Result<Self::ConnectionType>;
 }
 
 /// A handle to an async ADBC connection.
@@ -93,14 +91,15 @@ pub trait AsyncDatabase: AsyncOptionable<Option = OptionDatabase> {
 /// Connections should start in autocommit mode. They can be moved out by
 /// setting [options::OptionConnection::AutoCommit] to "false". Turning off
 /// autocommit allows customizing the isolation level.
-pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
-    type StatementType: AsyncStatement + Send;
+#[trait_variant::make(AsyncConnection: Send)]
+pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection> {
+    type StatementType: LocalAsyncStatement;
 
     /// Allocate and initialize a new statement.
-    fn new_statement(&mut self) -> impl Future<Output = Result<Self::StatementType>> + Send;
+    async fn new_statement(&mut self) -> Result<Self::StatementType>;
 
     /// Cancel the in-progress operation on a connection.
-    fn cancel(&mut self) -> impl Future<Output = Result<()>> + Send;
+    async fn cancel(&mut self) -> Result<()>;
 
     /// Get metadata about the database/driver.
     ///
@@ -127,10 +126,10 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
     /// int32_bitmask (3)           | int32
     /// string_list (4)             | list\<utf8\>
     /// int32_to_int32_list_map (5) | map\<int32, list\<int32\>\>
-    fn get_info(
+    async fn get_info(
         &self,
         codes: Option<HashSet<options::InfoCode>>,
-    ) -> impl Future<Output = Result<impl RecordBatchReader + Send>>;
+    ) -> Result<impl RecordBatchReader + Send>;
 
     /// Get a hierarchical view of all catalogs, database schemas, tables, and
     /// columns.
@@ -230,7 +229,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
     /// | fk_table                 | utf8 not null           |
     /// | fk_column_name           | utf8 not null           |
     ///
-    fn get_objects(
+    async fn get_objects(
         &self,
         depth: options::ObjectDepth,
         catalog: Option<&str>,
@@ -238,7 +237,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
         table_name: Option<&str>,
         table_type: Option<Vec<&str>>,
         column_name: Option<&str>,
-    ) -> impl Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+    ) -> Result<impl RecordBatchReader + Send>;
 
     /// Get the Arrow schema of a table.
     ///
@@ -247,12 +246,12 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
     /// - `catalog` - The catalog (or `None` if not applicable).
     /// - `db_schema` - The database schema (or `None` if not applicable).
     /// - `table_name` - The table name.
-    fn get_table_schema(
+    async fn get_table_schema(
         &self,
         catalog: Option<&str>,
         db_schema: Option<&str>,
         table_name: &str,
-    ) -> impl Future<Output = Result<Schema>> + Send;
+    ) -> Result<Schema>;
 
     /// Get a list of table types in the database.
     ///
@@ -263,8 +262,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
     /// Field Name     | Field Type
     /// ---------------|--------------
     /// table_type     | utf8 not null
-    fn get_table_types(&self)
-        -> impl Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+    async fn get_table_types(&self) -> Result<impl RecordBatchReader + Send>;
 
     /// Get the names of statistics specific to this driver.
     ///
@@ -279,9 +277,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
     ///
     /// # Since
     /// ADBC API revision 1.1.0
-    fn get_statistic_names(
-        &self,
-    ) -> impl Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+    async fn get_statistic_names(&self) -> Result<impl RecordBatchReader + Send>;
 
     /// Get statistics about the data distribution of table(s).
     ///
@@ -341,23 +337,23 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
     /// # Since
     ///
     /// ADBC API revision 1.1.0
-    fn get_statistics(
+    async fn get_statistics(
         &self,
         catalog: Option<&str>,
         db_schema: Option<&str>,
         table_name: Option<&str>,
         approximate: bool,
-    ) -> impl Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+    ) -> Result<impl RecordBatchReader + Send>;
 
     /// Commit any pending transactions. Only used if autocommit is disabled.
     ///
     /// Behavior is undefined if this is mixed with SQL transaction statements.
-    fn commit(&mut self) -> impl Future<Output = Result<()>> + Send;
+    async fn commit(&mut self) -> Result<()>;
 
     /// Roll back any pending transactions. Only used if autocommit is disabled.
     ///
     /// Behavior is undefined if this is mixed with SQL transaction statements.
-    fn rollback(&mut self) -> impl Future<Output = Result<()>> + Send;
+    async fn rollback(&mut self) -> Result<()>;
 
     /// Retrieve a given partition of data.
     ///
@@ -366,10 +362,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
     /// # Arguments
     ///
     /// - `partition` - The partition descriptor.
-    fn read_partition(
-        &self,
-        partition: impl AsRef<[u8]> + Send,
-    ) -> impl Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+    async fn read_partition(&self, partition: &[u8]) -> Result<impl RecordBatchReader + Send>;
 }
 
 /// A handle to an async ADBC statement.
@@ -388,19 +381,17 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> {
 /// Multiple statements may be created from a single connection.
 /// However, the driver may block or error if they are used concurrently
 /// (whether from a single thread or multiple threads).
-pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> {
+#[trait_variant::make(AsyncStatement: Send)]
+pub trait LocalAsyncStatement: LocalAsyncOptionable<Option = OptionStatement> {
     /// Bind Arrow data. This can be used for bulk inserts or prepared
     /// statements.
-    fn bind(&mut self, batch: RecordBatch) -> impl Future<Output = Result<()>> + Send;
+    async fn bind(&mut self, batch: RecordBatch) -> Result<()>;
 
     /// Bind Arrow data. This can be used for bulk inserts or prepared
     /// statements.
     // TODO(alexandreyc): should we use a generic here instead of a trait object?
     // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567750972
-    fn bind_stream(
-        &mut self,
-        reader: Box<dyn RecordBatchReader + Send>,
-    ) -> impl Future<Output = Result<()>> + Send;
+    async fn bind_stream(&mut self, reader: Box<dyn RecordBatchReader + Send>) -> Result<()>;
 
     /// Execute a statement and get the results.
     ///
@@ -408,7 +399,7 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> {
     // TODO(alexandreyc): is the Send bound absolutely necessary? same question
     // for all methods that return an impl RecordBatchReader
     // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567748242
-    fn execute(&mut self) -> impl Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+    async fn execute(&mut self) -> Result<impl RecordBatchReader + Send>;
 
     /// Execute a statement that doesn’t have a result set and get the number
     /// of affected rows.
@@ -419,7 +410,7 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> {
     ///
     /// Will return the number of rows affected. If the affected row count is
     /// unknown or unsupported by the database, will return `None`.
-    fn execute_update(&mut self) -> impl Future<Output = Result<Option<i64>>> + Send;
+    async fn execute_update(&mut self) -> Result<Option<i64>>;
 
     /// Get the schema of the result set of a query without executing it.
     ///
@@ -431,10 +422,10 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> {
     /// # Since
     ///
     /// ADBC API revision 1.1.0
-    fn execute_schema(&mut self) -> impl Future<Output = Result<Schema>> + Send;
+    async fn execute_schema(&mut self) -> Result<Schema>;
 
     /// Execute a statement and get the results as a partitioned result set.
-    fn execute_partitions(&mut self) -> impl Future<Output = Result<PartitionedResult>> + Send;
+    async fn execute_partitions(&mut self) -> Result<PartitionedResult>;
 
     /// Get the schema for bound parameters.
     ///
@@ -449,31 +440,25 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> {
     /// the corresponding field will be NA (NullType).
     ///
     /// This should be called after [AsyncStatement::prepare].
-    fn get_parameter_schema(&self) -> impl Future<Output = Result<Schema>> + Send;
+    async fn get_parameter_schema(&self) -> Result<Schema>;
 
     /// Turn this statement into a prepared statement to be executed multiple
     /// times.
     ///
     /// This invalidates any prior result sets.
-    fn prepare(&mut self) -> impl Future<Output = Result<()>> + Send;
+    async fn prepare(&mut self) -> Result<()>;
 
     /// Set the SQL query to execute.
     ///
     /// The query can then be executed with [AsyncStatement::execute]. For queries
     /// expected to be executed repeatedly, call [AsyncStatement::prepare] first.
-    fn set_sql_query(
-        &mut self,
-        query: impl AsRef<str> + Send,
-    ) -> impl Future<Output = Result<()>> + Send;
+    async fn set_sql_query(&mut self, query: &str) -> Result<()>;
 
     /// Set the Substrait plan to execute.
     ///
     /// The query can then be executed with [AsyncStatement::execute]. For queries
     /// expected to be executed repeatedly, call [AsyncStatement::prepare] first.
-    fn set_substrait_plan(
-        &mut self,
-        plan: impl AsRef<[u8]> + Send,
-    ) -> impl Future<Output = Result<()>>;
+    async fn set_substrait_plan(&mut self, plan: &[u8]) -> Result<()>;
 
     /// Cancel execution of an in-progress query.
     ///
@@ -483,5 +468,5 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> {
     /// # Since
     ///
     /// ADBC API revision 1.1.0
-    fn cancel(&mut self) -> impl Future<Output = Result<()>>;
+    async fn cancel(&mut self) -> Result<()>;
 }
diff --git a/rust/driver/datafusion/src/lib.rs b/rust/driver/datafusion/src/lib.rs
index be9ffaf469..3933f885c1 100644
--- a/rust/driver/datafusion/src/lib.rs
+++ b/rust/driver/datafusion/src/lib.rs
@@ -19,7 +19,7 @@
 mod syncify;
 
 use adbc_core::non_blocking::{
-    AsyncConnection, AsyncDatabase, AsyncDriver, AsyncOptionable, AsyncStatement,
+    AsyncConnection, AsyncDatabase, AsyncDriver, AsyncStatement, LocalAsyncOptionable,
 };
 use adbc_core::{constants, options};
 use datafusion::dataframe::DataFrameWriteOptions;
@@ -170,7 +170,7 @@ impl AsyncDriver for DataFusionDriver {
 
 pub struct DataFusionDatabase {}
 
-impl AsyncOptionable for DataFusionDatabase {
+impl LocalAsyncOptionable for DataFusionDatabase {
     type Option = OptionDatabase;
 
     async fn set_option(
@@ -242,7 +242,7 @@ pub struct DataFusionConnection {
     ctx: Arc<SessionContext>,
 }
 
-impl AsyncOptionable for DataFusionConnection {
+impl LocalAsyncOptionable for DataFusionConnection {
     type Option = OptionConnection;
 
     async fn set_option(
@@ -777,7 +777,7 @@ impl AsyncConnection for DataFusionConnection {
         todo!()
     }
 
-    async fn read_partition(&self, _partition: impl AsRef<[u8]>) -> Result<SingleBatchReader> {
+    async fn read_partition(&self, _partition: &[u8]) -> Result<SingleBatchReader> {
         todo!()
     }
 }
@@ -790,7 +790,7 @@ pub struct DataFusionStatement {
     ingest_target_table: Option<String>,
 }
 
-impl AsyncOptionable for DataFusionStatement {
+impl LocalAsyncOptionable for DataFusionStatement {
     type Option = OptionStatement;
 
     async fn set_option(
@@ -935,13 +935,13 @@ impl AsyncStatement for DataFusionStatement {
         todo!()
     }
 
-    async fn set_sql_query(&mut self, query: impl AsRef<str>) -> adbc_core::error::Result<()> {
-        self.sql_query = Some(query.as_ref().to_string());
+    async fn set_sql_query(&mut self, query: &str) -> adbc_core::error::Result<()> {
+        self.sql_query = Some(query.to_string());
         Ok(())
     }
 
-    async fn set_substrait_plan(&mut self, plan: impl AsRef<[u8]>) -> adbc_core::error::Result<()> {
-        self.substrait_plan = Some(Plan::decode(plan.as_ref()).unwrap());
+    async fn set_substrait_plan(&mut self, plan: &[u8]) -> adbc_core::error::Result<()> {
+        self.substrait_plan = Some(Plan::decode(plan).unwrap());
         Ok(())
     }
 
diff --git a/rust/driver/datafusion/src/syncify.rs b/rust/driver/datafusion/src/syncify.rs
index d63bc3fc9b..189eb35128 100644
--- a/rust/driver/datafusion/src/syncify.rs
+++ b/rust/driver/datafusion/src/syncify.rs
@@ -18,7 +18,9 @@
 use std::sync::Arc;
 
 use adbc_core::{
-    non_blocking::{AsyncConnection, AsyncDatabase, AsyncDriver, AsyncOptionable, AsyncStatement},
+    non_blocking::{
+        AsyncConnection, AsyncDatabase, AsyncDriver, AsyncStatement, LocalAsyncOptionable,
+    },
     options::{OptionConnection, OptionDatabase, OptionStatement},
     Connection, Database, Driver, Optionable, Statement,
 };
diff --git a/rust/driver/datafusion/tests/test_datafusion.rs b/rust/driver/datafusion/tests/test_datafusion.rs
index 0b27a170ff..7f76c466c9 100644
--- a/rust/driver/datafusion/tests/test_datafusion.rs
+++ b/rust/driver/datafusion/tests/test_datafusion.rs
@@ -16,7 +16,7 @@
 // under the License.
 
 use adbc_core::non_blocking::{
-    AsyncConnection, AsyncDatabase, AsyncDriver, AsyncOptionable, AsyncStatement,
+    AsyncConnection, AsyncDatabase, AsyncDriver, AsyncStatement, LocalAsyncOptionable,
 };
 use adbc_datafusion::{DataFusionConnection, DataFusionDriver};
 use arrow_array::RecordBatch;
@@ -78,7 +78,7 @@ async fn execute_sql_query(connection: &mut DataFusionConnection, query: &str) -
 async fn execute_substrait(connection: &mut DataFusionConnection, plan: Plan) -> RecordBatch {
     let mut statement = connection.new_statement().await.unwrap();
 
-    let _ = statement.set_substrait_plan(plan.encode_to_vec()).await;
+    let _ = statement.set_substrait_plan(&plan.encode_to_vec()).await;
 
     let batches: Vec<RecordBatch> = statement
         .execute()
@@ -229,4 +229,15 @@ async fn test_running_in_async() {
 
     assert_eq!(batch.num_rows(), 3);
     assert_eq!(batch.num_columns(), 2);
+
+    let batch = tokio::spawn(async move {
+        let batch =
+            execute_sql_query(&mut connection, "SELECT * FROM datafusion.public.example").await;
+        batch
+    })
+    .await
+    .unwrap();
+
+    assert_eq!(batch.num_rows(), 3);
+    assert_eq!(batch.num_columns(), 2);
 }

From a8ce3114ab1d286dcdb1f1a41b89fe2d3515595c Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Fri, 14 Nov 2025 16:29:03 +0300
Subject: [PATCH 05/14] changes: re-export non_blocking mod, blocking mod for
 sync traits, add sync wrappers

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/core/src/blocking.rs                     | 793 ++++++++++++++++++
 rust/core/src/executor.rs                     |  26 +
 rust/core/src/lib.rs                          | 467 +----------
 rust/core/src/non_blocking.rs                 |  21 +-
 rust/driver/datafusion/src/lib.rs             |  26 +-
 rust/driver/datafusion/src/syncify.rs         | 356 --------
 rust/driver/dummy/src/lib.rs                  |   5 +-
 .../dummy/tests/driver_exporter_dummy.rs      |   6 +-
 rust/driver/snowflake/src/connection.rs       |   6 +-
 .../snowflake/src/connection/builder.rs       |   2 +-
 rust/driver/snowflake/src/database.rs         |   4 +-
 rust/driver/snowflake/src/database/builder.rs |   2 +-
 rust/driver/snowflake/src/driver.rs           |   2 +-
 rust/driver/snowflake/src/statement.rs        |   5 +-
 rust/driver/snowflake/tests/driver.rs         |   2 +-
 rust/driver_manager/src/lib.rs                |   9 +-
 rust/driver_manager/tests/common/mod.rs       |   2 +-
 .../tests/driver_manager_sqlite.rs            |   5 +-
 rust/ffi/src/driver_exporter.rs               |   2 +-
 19 files changed, 892 insertions(+), 849 deletions(-)
 create mode 100644 rust/core/src/blocking.rs
 create mode 100644 rust/core/src/executor.rs
 delete mode 100644 rust/driver/datafusion/src/syncify.rs

diff --git a/rust/core/src/blocking.rs b/rust/core/src/blocking.rs
new file mode 100644
index 0000000000..669422ebd5
--- /dev/null
+++ b/rust/core/src/blocking.rs
@@ -0,0 +1,793 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::collections::HashSet;
+use std::sync::Arc;
+
+use arrow_array::{RecordBatch, RecordBatchReader};
+use arrow_schema::Schema;
+
+use crate::error::Result;
+use crate::executor::AsyncExecutor;
+use crate::non_blocking::PartitionedResult;
+use crate::options::{self, OptionConnection, OptionDatabase, OptionStatement, OptionValue};
+use crate::{
+    LocalAsyncConnection, LocalAsyncDatabase, LocalAsyncDriver, LocalAsyncOptionable,
+    LocalAsyncStatement,
+};
+
+/// Ability to configure an object by setting/getting options.
+pub trait Optionable {
+    type Option: AsRef<str>;
+
+    /// Set a post-init option.
+    fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()>;
+
+    /// Get a string option value by key.
+    fn get_option_string(&self, key: Self::Option) -> Result<String>;
+
+    /// Get a bytes option value by key.
+    fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>>;
+
+    /// Get an integer option value by key.
+    fn get_option_int(&self, key: Self::Option) -> Result<i64>;
+
+    /// Get a float option value by key.
+    fn get_option_double(&self, key: Self::Option) -> Result<f64>;
+}
+
+/// A handle to an ADBC driver.
+pub trait Driver {
+    type DatabaseType: Database;
+
+    /// Allocate and initialize a new database without pre-init options.
+    fn new_database(&mut self) -> Result<Self::DatabaseType>;
+
+    /// Allocate and initialize a new database with pre-init options.
+    fn new_database_with_opts(
+        &mut self,
+        opts: impl IntoIterator<Item = (OptionDatabase, OptionValue)>,
+    ) -> Result<Self::DatabaseType>;
+}
+
+/// A handle to an ADBC database.
+///
+/// Databases hold state shared by multiple connections. This typically means
+/// configuration and caches. For in-memory databases, it provides a place to
+/// hold ownership of the in-memory database.
+///
+/// Databases must be kept alive as long as any connections exist.
+pub trait Database: Optionable<Option = OptionDatabase> {
+    type ConnectionType: Connection;
+
+    /// Allocate and initialize a new connection without pre-init options.
+    fn new_connection(&self) -> Result<Self::ConnectionType>;
+
+    /// Allocate and initialize a new connection with pre-init options.
+    fn new_connection_with_opts(
+        &self,
+        opts: impl IntoIterator<Item = (options::OptionConnection, OptionValue)>,
+    ) -> Result<Self::ConnectionType>;
+}
+
+/// A handle to an ADBC connection.
+///
+/// Connections provide methods for query execution, managing prepared
+/// statements, using transactions, and so on.
+///
+/// # Autocommit
+///
+/// Connections should start in autocommit mode. They can be moved out by
+/// setting [options::OptionConnection::AutoCommit] to "false". Turning off
+/// autocommit allows customizing the isolation level.
+pub trait Connection: Optionable<Option = OptionConnection> {
+    type StatementType: Statement;
+
+    /// Allocate and initialize a new statement.
+    fn new_statement(&mut self) -> Result<Self::StatementType>;
+
+    /// Cancel the in-progress operation on a connection.
+    fn cancel(&mut self) -> Result<()>;
+
+    /// Get metadata about the database/driver.
+    ///
+    /// # Arguments
+    ///
+    /// - `codes` - Requested metadata. If `None`, retrieve all available metadata.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// Field Name                  | Field Type
+    /// ----------------------------|------------------------
+    /// info_name                   | uint32 not null
+    /// info_value                  | INFO_SCHEMA
+    ///
+    /// INFO_SCHEMA is a dense union with members:
+    ///
+    /// Field Name (Type Code)      | Field Type
+    /// ----------------------------|------------------------
+    /// string_value (0)            | utf8
+    /// bool_value (1)              | bool
+    /// int64_value (2)             | int64
+    /// int32_bitmask (3)           | int32
+    /// string_list (4)             | list\<utf8\>
+    /// int32_to_int32_list_map (5) | map\<int32, list\<int32\>\>
+    fn get_info(
+        &self,
+        codes: Option<HashSet<options::InfoCode>>,
+    ) -> Result<impl RecordBatchReader + Send>;
+
+    /// Get a hierarchical view of all catalogs, database schemas, tables, and
+    /// columns.
+    ///
+    /// # Arguments
+    ///
+    /// - `depth` - The level of nesting to query.
+    /// - `catalog` - Only show tables in the given catalog. If `None`,
+    ///   do not filter by catalog. If an empty string, only show tables
+    ///   without a catalog.  May be a search pattern.
+    /// - `db_schema` - Only show tables in the given database schema. If
+    ///   `None`, do not filter by database schema. If an empty string, only show
+    ///   tables without a database schema. May be a search pattern.
+    /// - `table_name` - Only show tables with the given name. If `None`, do not
+    ///   filter by name. May be a search pattern.
+    /// - `table_type` - Only show tables matching one of the given table
+    ///   types. If `None`, show tables of any type. Valid table types can be fetched
+    ///   from [Connection::get_table_types].
+    /// - `column_name` - Only show columns with the given name. If
+    ///   `None`, do not filter by name.  May be a search pattern..
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// | Field Name               | Field Type               |
+    /// |--------------------------|--------------------------|
+    /// | catalog_name             | utf8                     |
+    /// | catalog_db_schemas       | list\<DB_SCHEMA_SCHEMA\> |
+    ///
+    /// DB_SCHEMA_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              |
+    /// |--------------------------|-------------------------|
+    /// | db_schema_name           | utf8                    |
+    /// | db_schema_tables         | list\<TABLE_SCHEMA\>    |
+    ///
+    /// TABLE_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type                |
+    /// |--------------------------|---------------------------|
+    /// | table_name               | utf8 not null             |
+    /// | table_type               | utf8 not null             |
+    /// | table_columns            | list\<COLUMN_SCHEMA\>     |
+    /// | table_constraints        | list\<CONSTRAINT_SCHEMA\> |
+    ///
+    /// COLUMN_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              | Comments |
+    /// |--------------------------|-------------------------|----------|
+    /// | column_name              | utf8 not null           |          |
+    /// | ordinal_position         | int32                   | (1)      |
+    /// | remarks                  | utf8                    | (2)      |
+    /// | xdbc_data_type           | int16                   | (3)      |
+    /// | xdbc_type_name           | utf8                    | (3)      |
+    /// | xdbc_column_size         | int32                   | (3)      |
+    /// | xdbc_decimal_digits      | int16                   | (3)      |
+    /// | xdbc_num_prec_radix      | int16                   | (3)      |
+    /// | xdbc_nullable            | int16                   | (3)      |
+    /// | xdbc_column_def          | utf8                    | (3)      |
+    /// | xdbc_sql_data_type       | int16                   | (3)      |
+    /// | xdbc_datetime_sub        | int16                   | (3)      |
+    /// | xdbc_char_octet_length   | int32                   | (3)      |
+    /// | xdbc_is_nullable         | utf8                    | (3)      |
+    /// | xdbc_scope_catalog       | utf8                    | (3)      |
+    /// | xdbc_scope_schema        | utf8                    | (3)      |
+    /// | xdbc_scope_table         | utf8                    | (3)      |
+    /// | xdbc_is_autoincrement    | bool                    | (3)      |
+    /// | xdbc_is_generatedcolumn  | bool                    | (3)      |
+    ///
+    /// 1. The column's ordinal position in the table (starting from 1).
+    /// 2. Database-specific description of the column.
+    /// 3. Optional value.  Should be null if not supported by the driver.
+    ///    `xdbc_` values are meant to provide JDBC/ODBC-compatible metadata
+    ///    in an agnostic manner.
+    ///
+    /// CONSTRAINT_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              | Comments |
+    /// |--------------------------|-------------------------|----------|
+    /// | constraint_name          | utf8                    |          |
+    /// | constraint_type          | utf8 not null           | (1)      |
+    /// | constraint_column_names  | list\<utf8\> not null     | (2)      |
+    /// | constraint_column_usage  | list\<USAGE_SCHEMA\>      | (3)      |
+    ///
+    /// 1. One of `CHECK`, `FOREIGN KEY`, `PRIMARY KEY`, or `UNIQUE`.
+    /// 2. The columns on the current table that are constrained, in
+    ///    order.
+    /// 3. For `FOREIGN KEY` only, the referenced table and columns.
+    ///
+    /// USAGE_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              |
+    /// |--------------------------|-------------------------|
+    /// | fk_catalog               | utf8                    |
+    /// | fk_db_schema             | utf8                    |
+    /// | fk_table                 | utf8 not null           |
+    /// | fk_column_name           | utf8 not null           |
+    ///
+    fn get_objects(
+        &self,
+        depth: options::ObjectDepth,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        table_type: Option<Vec<&str>>,
+        column_name: Option<&str>,
+    ) -> Result<impl RecordBatchReader + Send>;
+
+    /// Get the Arrow schema of a table.
+    ///
+    /// # Arguments
+    ///
+    /// - `catalog` - The catalog (or `None` if not applicable).
+    /// - `db_schema` - The database schema (or `None` if not applicable).
+    /// - `table_name` - The table name.
+    fn get_table_schema(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: &str,
+    ) -> Result<Schema>;
+
+    /// Get a list of table types in the database.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// Field Name     | Field Type
+    /// ---------------|--------------
+    /// table_type     | utf8 not null
+    fn get_table_types(&self) -> Result<impl RecordBatchReader + Send>;
+
+    /// Get the names of statistics specific to this driver.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// Field Name     | Field Type
+    /// ---------------|----------------
+    /// statistic_name | utf8 not null
+    /// statistic_key  | int16 not null
+    ///
+    /// # Since
+    /// ADBC API revision 1.1.0
+    fn get_statistic_names(&self) -> Result<impl RecordBatchReader + Send>;
+
+    /// Get statistics about the data distribution of table(s).
+    ///
+    /// # Arguments
+    ///
+    /// - `catalog` - The catalog (or `None` if not applicable). May be a search pattern.
+    /// - `db_schema` - The database schema (or `None` if not applicable). May be a search pattern
+    /// - `table_name` - The table name (or `None` if not applicable). May be a search pattern
+    /// - `approximate` - If false, request exact values of statistics, else
+    ///   allow for best-effort, approximate, or cached values. The database may
+    ///   return approximate values regardless, as indicated in the result.
+    ///   Requesting exact values may be expensive or unsupported.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// | Field Name               | Field Type                       |
+    /// |--------------------------|----------------------------------|
+    /// | catalog_name             | utf8                             |
+    /// | catalog_db_schemas       | list\<DB_SCHEMA_SCHEMA\> not null|
+    ///
+    /// DB_SCHEMA_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type                        |
+    /// |--------------------------|-----------------------------------|
+    /// | db_schema_name           | utf8                              |
+    /// | db_schema_statistics     | list\<STATISTICS_SCHEMA\> not null|
+    ///
+    /// STATISTICS_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type                       | Comments |
+    /// |--------------------------|----------------------------------| -------- |
+    /// | table_name               | utf8 not null                    |          |
+    /// | column_name              | utf8                             | (1)      |
+    /// | statistic_key            | int16 not null                   | (2)      |
+    /// | statistic_value          | VALUE_SCHEMA not null            |          |
+    /// | statistic_is_approximate | bool not null                    | (3)      |
+    ///
+    /// 1. If null, then the statistic applies to the entire table.
+    /// 2. A dictionary-encoded statistic name (although we do not use the Arrow
+    ///    dictionary type). Values in [0, 1024) are reserved for ADBC.  Other
+    ///    values are for implementation-specific statistics.  For the definitions
+    ///    of predefined statistic types, see [options::Statistics]. To get
+    ///    driver-specific statistic names, use [Connection::get_statistic_names].
+    /// 3. If true, then the value is approximate or best-effort.
+    ///
+    /// VALUE_SCHEMA is a dense union with members:
+    ///
+    /// | Field Name               | Field Type                       |
+    /// |--------------------------|----------------------------------|
+    /// | int64                    | int64                            |
+    /// | uint64                   | uint64                           |
+    /// | float64                  | float64                          |
+    /// | binary                   | binary                           |
+    ///
+    /// # Since
+    ///
+    /// ADBC API revision 1.1.0
+    fn get_statistics(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        approximate: bool,
+    ) -> Result<impl RecordBatchReader + Send>;
+
+    /// Commit any pending transactions. Only used if autocommit is disabled.
+    ///
+    /// Behavior is undefined if this is mixed with SQL transaction statements.
+    fn commit(&mut self) -> Result<()>;
+
+    /// Roll back any pending transactions. Only used if autocommit is disabled.
+    ///
+    /// Behavior is undefined if this is mixed with SQL transaction statements.
+    fn rollback(&mut self) -> Result<()>;
+
+    /// Retrieve a given partition of data.
+    ///
+    /// A partition can be retrieved from [Statement::execute_partitions].
+    ///
+    /// # Arguments
+    ///
+    /// - `partition` - The partition descriptor.
+    fn read_partition(&self, partition: &[u8]) -> Result<impl RecordBatchReader + Send>;
+}
+
+/// A handle to an ADBC statement.
+///
+/// A statement is a container for all state needed to execute a database query,
+/// such as the query itself, parameters for prepared statements, driver
+/// parameters, etc.
+///
+/// Statements may represent queries or prepared statements.
+///
+/// Statements may be used multiple times and can be reconfigured
+/// (e.g. they can be reused to execute multiple different queries).
+/// However, executing a statement (and changing certain other state)
+/// will invalidate result sets obtained prior to that execution.
+///
+/// Multiple statements may be created from a single connection.
+/// However, the driver may block or error if they are used concurrently
+/// (whether from a single thread or multiple threads).
+pub trait Statement: Optionable<Option = OptionStatement> {
+    /// Bind Arrow data. This can be used for bulk inserts or prepared
+    /// statements.
+    fn bind(&mut self, batch: RecordBatch) -> Result<()>;
+
+    /// Bind Arrow data. This can be used for bulk inserts or prepared
+    /// statements.
+    // TODO(alexandreyc): should we use a generic here instead of a trait object?
+    // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567750972
+    fn bind_stream(&mut self, reader: Box<dyn RecordBatchReader + Send>) -> Result<()>;
+
+    /// Execute a statement and get the results.
+    ///
+    /// This invalidates any prior result sets.
+    // TODO(alexandreyc): is the Send bound absolutely necessary? same question
+    // for all methods that return an impl RecordBatchReader
+    // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567748242
+    fn execute(&mut self) -> Result<impl RecordBatchReader + Send>;
+
+    /// Execute a statement that doesn’t have a result set and get the number
+    /// of affected rows.
+    ///
+    /// This invalidates any prior result sets.
+    ///
+    /// # Result
+    ///
+    /// Will return the number of rows affected. If the affected row count is
+    /// unknown or unsupported by the database, will return `None`.
+    fn execute_update(&mut self) -> Result<Option<i64>>;
+
+    /// Get the schema of the result set of a query without executing it.
+    ///
+    /// This invalidates any prior result sets.
+    ///
+    /// Depending on the driver, this may require first executing
+    /// [Statement::prepare].
+    ///
+    /// # Since
+    ///
+    /// ADBC API revision 1.1.0
+    fn execute_schema(&mut self) -> Result<Schema>;
+
+    /// Execute a statement and get the results as a partitioned result set.
+    fn execute_partitions(&mut self) -> Result<PartitionedResult>;
+
+    /// Get the schema for bound parameters.
+    ///
+    /// This retrieves an Arrow schema describing the number, names, and
+    /// types of the parameters in a parameterized statement. The fields
+    /// of the schema should be in order of the ordinal position of the
+    /// parameters; named parameters should appear only once.
+    ///
+    /// If the parameter does not have a name, or the name cannot be
+    /// determined, the name of the corresponding field in the schema will
+    /// be an empty string. If the type cannot be determined, the type of
+    /// the corresponding field will be NA (NullType).
+    ///
+    /// This should be called after [Statement::prepare].
+    fn get_parameter_schema(&self) -> Result<Schema>;
+
+    /// Turn this statement into a prepared statement to be executed multiple
+    /// times.
+    ///
+    /// This invalidates any prior result sets.
+    fn prepare(&mut self) -> Result<()>;
+
+    /// Set the SQL query to execute.
+    ///
+    /// The query can then be executed with [Statement::execute]. For queries
+    /// expected to be executed repeatedly, call [Statement::prepare] first.
+    fn set_sql_query(&mut self, query: impl AsRef<str>) -> Result<()>;
+
+    /// Set the Substrait plan to execute.
+    ///
+    /// The query can then be executed with [Statement::execute]. For queries
+    /// expected to be executed repeatedly, call [Statement::prepare] first.
+    fn set_substrait_plan(&mut self, plan: impl AsRef<[u8]>) -> Result<()>;
+
+    /// Cancel execution of an in-progress query.
+    ///
+    /// This can be called during [Statement::execute] (or similar), or while
+    /// consuming a result set returned from such.
+    ///
+    /// # Since
+    ///
+    /// ADBC API revision 1.1.0
+    fn cancel(&mut self) -> Result<()>;
+}
+
+pub struct SyncDriverWrapper<A, D> {
+    inner: D,
+    executor: Arc<A>,
+}
+
+impl<A: AsyncExecutor, D: Default> Default for SyncDriverWrapper<A, D> {
+    fn default() -> Self {
+        Self {
+            inner: Default::default(),
+            executor: Arc::new(A::new(Default::default()).expect("failed to create executor")),
+        }
+    }
+}
+
+impl<A, D> Driver for SyncDriverWrapper<A, D>
+where
+    A: AsyncExecutor,
+    D: LocalAsyncDriver,
+    D::DatabaseType: LocalAsyncDatabase + LocalAsyncOptionable<Option = OptionDatabase>,
+    <D::DatabaseType as LocalAsyncDatabase>::ConnectionType:
+        LocalAsyncConnection + LocalAsyncOptionable<Option = OptionConnection>,
+    <<D::DatabaseType as LocalAsyncDatabase>::ConnectionType as LocalAsyncConnection>::StatementType: LocalAsyncOptionable<Option = OptionStatement>,
+{
+    type DatabaseType = SyncDatabaseWrapper<A, D::DatabaseType>;
+
+    fn new_database(&mut self) -> Result<Self::DatabaseType> {
+        let db = self.executor.block_on(self.inner.new_database())?;
+
+        Ok(SyncDatabaseWrapper { inner: db, executor: self.executor.clone() })
+    }
+
+    fn new_database_with_opts(
+        &mut self,
+        opts: impl IntoIterator<Item = (OptionDatabase, OptionValue)>,
+    ) -> Result<Self::DatabaseType> {
+        let db = self.executor.block_on(self.inner.new_database_with_opts(opts.into_iter().collect()))?;
+
+        Ok(SyncDatabaseWrapper { inner: db, executor: self.executor.clone() })
+    }
+}
+
+pub struct SyncDatabaseWrapper<A, DB> {
+    inner: DB,
+    executor: Arc<A>,
+}
+
+impl<A, DB> Optionable for SyncDatabaseWrapper<A, DB>
+where
+    A: AsyncExecutor,
+    DB: LocalAsyncOptionable<Option = OptionDatabase>,
+{
+    type Option = OptionDatabase;
+
+    fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()> {
+        self.executor.block_on(self.inner.set_option(key, value))
+    }
+
+    fn get_option_string(&self, key: Self::Option) -> Result<String> {
+        self.executor.block_on(self.inner.get_option_string(key))
+    }
+
+    fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>> {
+        self.executor.block_on(self.inner.get_option_bytes(key))
+    }
+
+    fn get_option_int(&self, key: Self::Option) -> Result<i64> {
+        self.executor.block_on(self.inner.get_option_int(key))
+    }
+
+    fn get_option_double(&self, key: Self::Option) -> Result<f64> {
+        self.executor.block_on(self.inner.get_option_double(key))
+    }
+}
+
+impl<A, DB> Database for SyncDatabaseWrapper<A, DB>
+where
+    A: AsyncExecutor,
+    DB: LocalAsyncDatabase + LocalAsyncOptionable<Option = OptionDatabase>,
+    DB::ConnectionType: LocalAsyncConnection + LocalAsyncOptionable<Option = OptionConnection>,
+    <DB::ConnectionType as LocalAsyncConnection>::StatementType:
+        LocalAsyncOptionable<Option = OptionStatement>,
+{
+    type ConnectionType = SyncConnectionWrapper<A, DB::ConnectionType>;
+
+    fn new_connection(&self) -> Result<Self::ConnectionType> {
+        let conn = self.executor.block_on(self.inner.new_connection())?;
+
+        Ok(SyncConnectionWrapper {
+            inner: conn,
+            executor: self.executor.clone(),
+        })
+    }
+
+    fn new_connection_with_opts(
+        &self,
+        opts: impl IntoIterator<Item = (options::OptionConnection, OptionValue)>,
+    ) -> Result<Self::ConnectionType> {
+        let conn = self.executor.block_on(
+            self.inner
+                .new_connection_with_opts(opts.into_iter().collect()),
+        )?;
+
+        Ok(SyncConnectionWrapper {
+            inner: conn,
+            executor: self.executor.clone(),
+        })
+    }
+}
+
+pub struct SyncConnectionWrapper<A, Conn> {
+    inner: Conn,
+    executor: Arc<A>,
+}
+
+impl<A, Conn> Optionable for SyncConnectionWrapper<A, Conn>
+where
+    A: AsyncExecutor,
+    Conn: LocalAsyncOptionable<Option = OptionConnection>,
+{
+    type Option = OptionConnection;
+
+    fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()> {
+        self.executor.block_on(self.inner.set_option(key, value))
+    }
+
+    fn get_option_string(&self, key: Self::Option) -> Result<String> {
+        self.executor.block_on(self.inner.get_option_string(key))
+    }
+
+    fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>> {
+        self.executor.block_on(self.inner.get_option_bytes(key))
+    }
+
+    fn get_option_int(&self, key: Self::Option) -> Result<i64> {
+        self.executor.block_on(self.inner.get_option_int(key))
+    }
+
+    fn get_option_double(&self, key: Self::Option) -> Result<f64> {
+        self.executor.block_on(self.inner.get_option_double(key))
+    }
+}
+
+impl<A, Conn> Connection for SyncConnectionWrapper<A, Conn>
+where
+    A: AsyncExecutor,
+    Conn: LocalAsyncConnection + LocalAsyncOptionable<Option = OptionConnection>,
+    Conn::StatementType: LocalAsyncOptionable<Option = OptionStatement>,
+{
+    type StatementType = SyncStatementWrapper<A, Conn::StatementType>;
+
+    fn new_statement(&mut self) -> Result<Self::StatementType> {
+        let stmt = self.executor.block_on(self.inner.new_statement())?;
+
+        Ok(SyncStatementWrapper {
+            inner: stmt,
+            executor: self.executor.clone(),
+        })
+    }
+
+    fn cancel(&mut self) -> Result<()> {
+        self.executor.block_on(self.inner.cancel())
+    }
+
+    fn get_info(
+        &self,
+        codes: Option<HashSet<options::InfoCode>>,
+    ) -> Result<impl RecordBatchReader + Send> {
+        self.executor.block_on(self.inner.get_info(codes))
+    }
+
+    fn get_objects(
+        &self,
+        depth: options::ObjectDepth,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        table_type: Option<Vec<&str>>,
+        column_name: Option<&str>,
+    ) -> Result<impl RecordBatchReader + Send> {
+        self.executor.block_on(self.inner.get_objects(
+            depth,
+            catalog,
+            db_schema,
+            table_name,
+            table_type,
+            column_name,
+        ))
+    }
+
+    fn get_table_schema(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: &str,
+    ) -> Result<Schema> {
+        self.executor
+            .block_on(self.inner.get_table_schema(catalog, db_schema, table_name))
+    }
+
+    fn get_table_types(&self) -> Result<impl RecordBatchReader + Send> {
+        self.executor.block_on(self.inner.get_table_types())
+    }
+
+    fn get_statistic_names(&self) -> Result<impl RecordBatchReader + Send> {
+        self.executor.block_on(self.inner.get_statistic_names())
+    }
+
+    fn get_statistics(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        approximate: bool,
+    ) -> Result<impl RecordBatchReader + Send> {
+        self.executor.block_on(self.inner.get_statistics(
+            catalog,
+            db_schema,
+            table_name,
+            approximate,
+        ))
+    }
+
+    fn commit(&mut self) -> Result<()> {
+        self.executor.block_on(self.inner.commit())
+    }
+
+    fn rollback(&mut self) -> Result<()> {
+        self.executor.block_on(self.inner.rollback())
+    }
+
+    fn read_partition(&self, partition: &[u8]) -> Result<impl RecordBatchReader + Send> {
+        self.executor.block_on(self.inner.read_partition(partition))
+    }
+}
+
+pub struct SyncStatementWrapper<A, T> {
+    inner: T,
+    executor: Arc<A>,
+}
+
+impl<A, Stmt> Optionable for SyncStatementWrapper<A, Stmt>
+where
+    A: AsyncExecutor,
+    Stmt: LocalAsyncOptionable<Option = OptionStatement>,
+{
+    type Option = OptionStatement;
+
+    fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()> {
+        self.executor.block_on(self.inner.set_option(key, value))
+    }
+
+    fn get_option_string(&self, key: Self::Option) -> Result<String> {
+        self.executor.block_on(self.inner.get_option_string(key))
+    }
+
+    fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>> {
+        self.executor.block_on(self.inner.get_option_bytes(key))
+    }
+
+    fn get_option_int(&self, key: Self::Option) -> Result<i64> {
+        self.executor.block_on(self.inner.get_option_int(key))
+    }
+
+    fn get_option_double(&self, key: Self::Option) -> Result<f64> {
+        self.executor.block_on(self.inner.get_option_double(key))
+    }
+}
+
+impl<A, Stmt> Statement for SyncStatementWrapper<A, Stmt>
+where
+    A: AsyncExecutor,
+    Stmt: LocalAsyncStatement + LocalAsyncOptionable<Option = OptionStatement>,
+{
+    fn bind(&mut self, batch: RecordBatch) -> Result<()> {
+        self.executor.block_on(self.inner.bind(batch))
+    }
+
+    fn bind_stream(&mut self, reader: Box<dyn RecordBatchReader + Send>) -> Result<()> {
+        self.executor.block_on(self.inner.bind_stream(reader))
+    }
+
+    fn execute(&mut self) -> Result<impl RecordBatchReader + Send> {
+        self.executor.block_on(self.inner.execute())
+    }
+
+    fn execute_update(&mut self) -> Result<Option<i64>> {
+        self.executor.block_on(self.inner.execute_update())
+    }
+
+    fn execute_schema(&mut self) -> Result<Schema> {
+        self.executor.block_on(self.inner.execute_schema())
+    }
+
+    fn execute_partitions(&mut self) -> Result<PartitionedResult> {
+        self.executor.block_on(self.inner.execute_partitions())
+    }
+
+    fn get_parameter_schema(&self) -> Result<Schema> {
+        self.executor.block_on(self.inner.get_parameter_schema())
+    }
+
+    fn prepare(&mut self) -> Result<()> {
+        self.executor.block_on(self.inner.prepare())
+    }
+
+    fn set_sql_query(&mut self, query: impl AsRef<str>) -> Result<()> {
+        self.executor
+            .block_on(self.inner.set_sql_query(query.as_ref()))
+    }
+
+    fn set_substrait_plan(&mut self, plan: impl AsRef<[u8]>) -> Result<()> {
+        self.executor
+            .block_on(self.inner.set_substrait_plan(plan.as_ref()))
+    }
+
+    fn cancel(&mut self) -> Result<()> {
+        self.executor.block_on(self.inner.cancel())
+    }
+}
diff --git a/rust/core/src/executor.rs b/rust/core/src/executor.rs
new file mode 100644
index 0000000000..dcb45ee7fd
--- /dev/null
+++ b/rust/core/src/executor.rs
@@ -0,0 +1,26 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::{fmt::Debug, future::Future};
+
+pub trait AsyncExecutor: Sized {
+    type Config: Default;
+    type Error: Debug;
+
+    fn new(config: Self::Config) -> Result<Self, Self::Error>;
+    fn block_on<F: Future>(&self, future: F) -> F::Output;
+}
diff --git a/rust/core/src/lib.rs b/rust/core/src/lib.rs
index c9e599c920..871d8d9cc4 100644
--- a/rust/core/src/lib.rs
+++ b/rust/core/src/lib.rs
@@ -39,20 +39,14 @@
 //! For drivers implemented in Rust, using these will be more efficient and
 //! safe, since it avoids the overhead of going through C FFI.
 
+pub mod blocking;
 pub mod constants;
 pub mod error;
+pub mod executor;
 pub mod non_blocking;
 pub mod options;
 pub mod schemas;
 
-use std::collections::HashSet;
-
-use arrow_array::{RecordBatch, RecordBatchReader};
-use arrow_schema::Schema;
-
-use error::Result;
-use options::{OptionConnection, OptionDatabase, OptionStatement, OptionValue};
-
 pub type LoadFlags = u32;
 
 pub const LOAD_FLAG_SEARCH_ENV: LoadFlags = 1 << 1;
@@ -64,459 +58,4 @@ pub const LOAD_FLAG_DEFAULT: LoadFlags = LOAD_FLAG_SEARCH_ENV
     | LOAD_FLAG_SEARCH_SYSTEM
     | LOAD_FLAG_ALLOW_RELATIVE_PATHS;
 
-/// Ability to configure an object by setting/getting options.
-pub trait Optionable {
-    type Option: AsRef<str>;
-
-    /// Set a post-init option.
-    fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()>;
-
-    /// Get a string option value by key.
-    fn get_option_string(&self, key: Self::Option) -> Result<String>;
-
-    /// Get a bytes option value by key.
-    fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>>;
-
-    /// Get an integer option value by key.
-    fn get_option_int(&self, key: Self::Option) -> Result<i64>;
-
-    /// Get a float option value by key.
-    fn get_option_double(&self, key: Self::Option) -> Result<f64>;
-}
-
-/// A handle to an ADBC driver.
-pub trait Driver {
-    type DatabaseType: Database;
-
-    /// Allocate and initialize a new database without pre-init options.
-    fn new_database(&mut self) -> Result<Self::DatabaseType>;
-
-    /// Allocate and initialize a new database with pre-init options.
-    fn new_database_with_opts(
-        &mut self,
-        opts: impl IntoIterator<Item = (OptionDatabase, OptionValue)>,
-    ) -> Result<Self::DatabaseType>;
-}
-
-/// A handle to an ADBC database.
-///
-/// Databases hold state shared by multiple connections. This typically means
-/// configuration and caches. For in-memory databases, it provides a place to
-/// hold ownership of the in-memory database.
-///
-/// Databases must be kept alive as long as any connections exist.
-pub trait Database: Optionable<Option = OptionDatabase> {
-    type ConnectionType: Connection;
-
-    /// Allocate and initialize a new connection without pre-init options.
-    fn new_connection(&self) -> Result<Self::ConnectionType>;
-
-    /// Allocate and initialize a new connection with pre-init options.
-    fn new_connection_with_opts(
-        &self,
-        opts: impl IntoIterator<Item = (options::OptionConnection, OptionValue)>,
-    ) -> Result<Self::ConnectionType>;
-}
-
-/// A handle to an ADBC connection.
-///
-/// Connections provide methods for query execution, managing prepared
-/// statements, using transactions, and so on.
-///
-/// # Autocommit
-///
-/// Connections should start in autocommit mode. They can be moved out by
-/// setting [options::OptionConnection::AutoCommit] to "false". Turning off
-/// autocommit allows customizing the isolation level.
-pub trait Connection: Optionable<Option = OptionConnection> {
-    type StatementType: Statement;
-
-    /// Allocate and initialize a new statement.
-    fn new_statement(&mut self) -> Result<Self::StatementType>;
-
-    /// Cancel the in-progress operation on a connection.
-    fn cancel(&mut self) -> Result<()>;
-
-    /// Get metadata about the database/driver.
-    ///
-    /// # Arguments
-    ///
-    /// - `codes` - Requested metadata. If `None`, retrieve all available metadata.
-    ///
-    /// # Result
-    ///
-    /// The result is an Arrow dataset with the following schema:
-    ///
-    /// Field Name                  | Field Type
-    /// ----------------------------|------------------------
-    /// info_name                   | uint32 not null
-    /// info_value                  | INFO_SCHEMA
-    ///
-    /// INFO_SCHEMA is a dense union with members:
-    ///
-    /// Field Name (Type Code)      | Field Type
-    /// ----------------------------|------------------------
-    /// string_value (0)            | utf8
-    /// bool_value (1)              | bool
-    /// int64_value (2)             | int64
-    /// int32_bitmask (3)           | int32
-    /// string_list (4)             | list\<utf8\>
-    /// int32_to_int32_list_map (5) | map\<int32, list\<int32\>\>
-    fn get_info(
-        &self,
-        codes: Option<HashSet<options::InfoCode>>,
-    ) -> Result<impl RecordBatchReader + Send>;
-
-    /// Get a hierarchical view of all catalogs, database schemas, tables, and
-    /// columns.
-    ///
-    /// # Arguments
-    ///
-    /// - `depth` - The level of nesting to query.
-    /// - `catalog` - Only show tables in the given catalog. If `None`,
-    ///   do not filter by catalog. If an empty string, only show tables
-    ///   without a catalog.  May be a search pattern.
-    /// - `db_schema` - Only show tables in the given database schema. If
-    ///   `None`, do not filter by database schema. If an empty string, only show
-    ///   tables without a database schema. May be a search pattern.
-    /// - `table_name` - Only show tables with the given name. If `None`, do not
-    ///   filter by name. May be a search pattern.
-    /// - `table_type` - Only show tables matching one of the given table
-    ///   types. If `None`, show tables of any type. Valid table types can be fetched
-    ///   from [Connection::get_table_types].
-    /// - `column_name` - Only show columns with the given name. If
-    ///   `None`, do not filter by name.  May be a search pattern..
-    ///
-    /// # Result
-    ///
-    /// The result is an Arrow dataset with the following schema:
-    ///
-    /// | Field Name               | Field Type               |
-    /// |--------------------------|--------------------------|
-    /// | catalog_name             | utf8                     |
-    /// | catalog_db_schemas       | list\<DB_SCHEMA_SCHEMA\> |
-    ///
-    /// DB_SCHEMA_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type              |
-    /// |--------------------------|-------------------------|
-    /// | db_schema_name           | utf8                    |
-    /// | db_schema_tables         | list\<TABLE_SCHEMA\>    |
-    ///
-    /// TABLE_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type                |
-    /// |--------------------------|---------------------------|
-    /// | table_name               | utf8 not null             |
-    /// | table_type               | utf8 not null             |
-    /// | table_columns            | list\<COLUMN_SCHEMA\>     |
-    /// | table_constraints        | list\<CONSTRAINT_SCHEMA\> |
-    ///
-    /// COLUMN_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type              | Comments |
-    /// |--------------------------|-------------------------|----------|
-    /// | column_name              | utf8 not null           |          |
-    /// | ordinal_position         | int32                   | (1)      |
-    /// | remarks                  | utf8                    | (2)      |
-    /// | xdbc_data_type           | int16                   | (3)      |
-    /// | xdbc_type_name           | utf8                    | (3)      |
-    /// | xdbc_column_size         | int32                   | (3)      |
-    /// | xdbc_decimal_digits      | int16                   | (3)      |
-    /// | xdbc_num_prec_radix      | int16                   | (3)      |
-    /// | xdbc_nullable            | int16                   | (3)      |
-    /// | xdbc_column_def          | utf8                    | (3)      |
-    /// | xdbc_sql_data_type       | int16                   | (3)      |
-    /// | xdbc_datetime_sub        | int16                   | (3)      |
-    /// | xdbc_char_octet_length   | int32                   | (3)      |
-    /// | xdbc_is_nullable         | utf8                    | (3)      |
-    /// | xdbc_scope_catalog       | utf8                    | (3)      |
-    /// | xdbc_scope_schema        | utf8                    | (3)      |
-    /// | xdbc_scope_table         | utf8                    | (3)      |
-    /// | xdbc_is_autoincrement    | bool                    | (3)      |
-    /// | xdbc_is_generatedcolumn  | bool                    | (3)      |
-    ///
-    /// 1. The column's ordinal position in the table (starting from 1).
-    /// 2. Database-specific description of the column.
-    /// 3. Optional value.  Should be null if not supported by the driver.
-    ///    `xdbc_` values are meant to provide JDBC/ODBC-compatible metadata
-    ///    in an agnostic manner.
-    ///
-    /// CONSTRAINT_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type              | Comments |
-    /// |--------------------------|-------------------------|----------|
-    /// | constraint_name          | utf8                    |          |
-    /// | constraint_type          | utf8 not null           | (1)      |
-    /// | constraint_column_names  | list\<utf8\> not null     | (2)      |
-    /// | constraint_column_usage  | list\<USAGE_SCHEMA\>      | (3)      |
-    ///
-    /// 1. One of `CHECK`, `FOREIGN KEY`, `PRIMARY KEY`, or `UNIQUE`.
-    /// 2. The columns on the current table that are constrained, in
-    ///    order.
-    /// 3. For `FOREIGN KEY` only, the referenced table and columns.
-    ///
-    /// USAGE_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type              |
-    /// |--------------------------|-------------------------|
-    /// | fk_catalog               | utf8                    |
-    /// | fk_db_schema             | utf8                    |
-    /// | fk_table                 | utf8 not null           |
-    /// | fk_column_name           | utf8 not null           |
-    ///
-    fn get_objects(
-        &self,
-        depth: options::ObjectDepth,
-        catalog: Option<&str>,
-        db_schema: Option<&str>,
-        table_name: Option<&str>,
-        table_type: Option<Vec<&str>>,
-        column_name: Option<&str>,
-    ) -> Result<impl RecordBatchReader + Send>;
-
-    /// Get the Arrow schema of a table.
-    ///
-    /// # Arguments
-    ///
-    /// - `catalog` - The catalog (or `None` if not applicable).
-    /// - `db_schema` - The database schema (or `None` if not applicable).
-    /// - `table_name` - The table name.
-    fn get_table_schema(
-        &self,
-        catalog: Option<&str>,
-        db_schema: Option<&str>,
-        table_name: &str,
-    ) -> Result<Schema>;
-
-    /// Get a list of table types in the database.
-    ///
-    /// # Result
-    ///
-    /// The result is an Arrow dataset with the following schema:
-    ///
-    /// Field Name     | Field Type
-    /// ---------------|--------------
-    /// table_type     | utf8 not null
-    fn get_table_types(&self) -> Result<impl RecordBatchReader + Send>;
-
-    /// Get the names of statistics specific to this driver.
-    ///
-    /// # Result
-    ///
-    /// The result is an Arrow dataset with the following schema:
-    ///
-    /// Field Name     | Field Type
-    /// ---------------|----------------
-    /// statistic_name | utf8 not null
-    /// statistic_key  | int16 not null
-    ///
-    /// # Since
-    /// ADBC API revision 1.1.0
-    fn get_statistic_names(&self) -> Result<impl RecordBatchReader + Send>;
-
-    /// Get statistics about the data distribution of table(s).
-    ///
-    /// # Arguments
-    ///
-    /// - `catalog` - The catalog (or `None` if not applicable). May be a search pattern.
-    /// - `db_schema` - The database schema (or `None` if not applicable). May be a search pattern
-    /// - `table_name` - The table name (or `None` if not applicable). May be a search pattern
-    /// - `approximate` - If false, request exact values of statistics, else
-    ///   allow for best-effort, approximate, or cached values. The database may
-    ///   return approximate values regardless, as indicated in the result.
-    ///   Requesting exact values may be expensive or unsupported.
-    ///
-    /// # Result
-    ///
-    /// The result is an Arrow dataset with the following schema:
-    ///
-    /// | Field Name               | Field Type                       |
-    /// |--------------------------|----------------------------------|
-    /// | catalog_name             | utf8                             |
-    /// | catalog_db_schemas       | list\<DB_SCHEMA_SCHEMA\> not null|
-    ///
-    /// DB_SCHEMA_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type                        |
-    /// |--------------------------|-----------------------------------|
-    /// | db_schema_name           | utf8                              |
-    /// | db_schema_statistics     | list\<STATISTICS_SCHEMA\> not null|
-    ///
-    /// STATISTICS_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type                       | Comments |
-    /// |--------------------------|----------------------------------| -------- |
-    /// | table_name               | utf8 not null                    |          |
-    /// | column_name              | utf8                             | (1)      |
-    /// | statistic_key            | int16 not null                   | (2)      |
-    /// | statistic_value          | VALUE_SCHEMA not null            |          |
-    /// | statistic_is_approximate | bool not null                    | (3)      |
-    ///
-    /// 1. If null, then the statistic applies to the entire table.
-    /// 2. A dictionary-encoded statistic name (although we do not use the Arrow
-    ///    dictionary type). Values in [0, 1024) are reserved for ADBC.  Other
-    ///    values are for implementation-specific statistics.  For the definitions
-    ///    of predefined statistic types, see [options::Statistics]. To get
-    ///    driver-specific statistic names, use [Connection::get_statistic_names].
-    /// 3. If true, then the value is approximate or best-effort.
-    ///
-    /// VALUE_SCHEMA is a dense union with members:
-    ///
-    /// | Field Name               | Field Type                       |
-    /// |--------------------------|----------------------------------|
-    /// | int64                    | int64                            |
-    /// | uint64                   | uint64                           |
-    /// | float64                  | float64                          |
-    /// | binary                   | binary                           |
-    ///
-    /// # Since
-    ///
-    /// ADBC API revision 1.1.0
-    fn get_statistics(
-        &self,
-        catalog: Option<&str>,
-        db_schema: Option<&str>,
-        table_name: Option<&str>,
-        approximate: bool,
-    ) -> Result<impl RecordBatchReader + Send>;
-
-    /// Commit any pending transactions. Only used if autocommit is disabled.
-    ///
-    /// Behavior is undefined if this is mixed with SQL transaction statements.
-    fn commit(&mut self) -> Result<()>;
-
-    /// Roll back any pending transactions. Only used if autocommit is disabled.
-    ///
-    /// Behavior is undefined if this is mixed with SQL transaction statements.
-    fn rollback(&mut self) -> Result<()>;
-
-    /// Retrieve a given partition of data.
-    ///
-    /// A partition can be retrieved from [Statement::execute_partitions].
-    ///
-    /// # Arguments
-    ///
-    /// - `partition` - The partition descriptor.
-    fn read_partition(&self, partition: impl AsRef<[u8]>) -> Result<impl RecordBatchReader + Send>;
-}
-
-/// A handle to an ADBC statement.
-///
-/// A statement is a container for all state needed to execute a database query,
-/// such as the query itself, parameters for prepared statements, driver
-/// parameters, etc.
-///
-/// Statements may represent queries or prepared statements.
-///
-/// Statements may be used multiple times and can be reconfigured
-/// (e.g. they can be reused to execute multiple different queries).
-/// However, executing a statement (and changing certain other state)
-/// will invalidate result sets obtained prior to that execution.
-///
-/// Multiple statements may be created from a single connection.
-/// However, the driver may block or error if they are used concurrently
-/// (whether from a single thread or multiple threads).
-pub trait Statement: Optionable<Option = OptionStatement> {
-    /// Bind Arrow data. This can be used for bulk inserts or prepared
-    /// statements.
-    fn bind(&mut self, batch: RecordBatch) -> Result<()>;
-
-    /// Bind Arrow data. This can be used for bulk inserts or prepared
-    /// statements.
-    // TODO(alexandreyc): should we use a generic here instead of a trait object?
-    // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567750972
-    fn bind_stream(&mut self, reader: Box<dyn RecordBatchReader + Send>) -> Result<()>;
-
-    /// Execute a statement and get the results.
-    ///
-    /// This invalidates any prior result sets.
-    // TODO(alexandreyc): is the Send bound absolutely necessary? same question
-    // for all methods that return an impl RecordBatchReader
-    // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567748242
-    fn execute(&mut self) -> Result<impl RecordBatchReader + Send>;
-
-    /// Execute a statement that doesn’t have a result set and get the number
-    /// of affected rows.
-    ///
-    /// This invalidates any prior result sets.
-    ///
-    /// # Result
-    ///
-    /// Will return the number of rows affected. If the affected row count is
-    /// unknown or unsupported by the database, will return `None`.
-    fn execute_update(&mut self) -> Result<Option<i64>>;
-
-    /// Get the schema of the result set of a query without executing it.
-    ///
-    /// This invalidates any prior result sets.
-    ///
-    /// Depending on the driver, this may require first executing
-    /// [Statement::prepare].
-    ///
-    /// # Since
-    ///
-    /// ADBC API revision 1.1.0
-    fn execute_schema(&mut self) -> Result<Schema>;
-
-    /// Execute a statement and get the results as a partitioned result set.
-    fn execute_partitions(&mut self) -> Result<PartitionedResult>;
-
-    /// Get the schema for bound parameters.
-    ///
-    /// This retrieves an Arrow schema describing the number, names, and
-    /// types of the parameters in a parameterized statement. The fields
-    /// of the schema should be in order of the ordinal position of the
-    /// parameters; named parameters should appear only once.
-    ///
-    /// If the parameter does not have a name, or the name cannot be
-    /// determined, the name of the corresponding field in the schema will
-    /// be an empty string. If the type cannot be determined, the type of
-    /// the corresponding field will be NA (NullType).
-    ///
-    /// This should be called after [Statement::prepare].
-    fn get_parameter_schema(&self) -> Result<Schema>;
-
-    /// Turn this statement into a prepared statement to be executed multiple
-    /// times.
-    ///
-    /// This invalidates any prior result sets.
-    fn prepare(&mut self) -> Result<()>;
-
-    /// Set the SQL query to execute.
-    ///
-    /// The query can then be executed with [Statement::execute]. For queries
-    /// expected to be executed repeatedly, call [Statement::prepare] first.
-    fn set_sql_query(&mut self, query: impl AsRef<str>) -> Result<()>;
-
-    /// Set the Substrait plan to execute.
-    ///
-    /// The query can then be executed with [Statement::execute]. For queries
-    /// expected to be executed repeatedly, call [Statement::prepare] first.
-    fn set_substrait_plan(&mut self, plan: impl AsRef<[u8]>) -> Result<()>;
-
-    /// Cancel execution of an in-progress query.
-    ///
-    /// This can be called during [Statement::execute] (or similar), or while
-    /// consuming a result set returned from such.
-    ///
-    /// # Since
-    ///
-    /// ADBC API revision 1.1.0
-    fn cancel(&mut self) -> Result<()>;
-}
-
-/// Each data partition is described by an opaque byte array and can be
-/// retrieved with [Connection::read_partition].
-pub type Partitions = Vec<Vec<u8>>;
-
-/// A partitioned result set as returned by [Statement::execute_partitions].
-#[derive(Debug, PartialEq, Eq)]
-pub struct PartitionedResult {
-    /// The result partitions.
-    pub partitions: Partitions,
-    /// The schema of the result set.
-    pub schema: Schema,
-    /// The number of rows affected if known, else -1.
-    pub rows_affected: i64,
-}
+pub use non_blocking::*;
diff --git a/rust/core/src/non_blocking.rs b/rust/core/src/non_blocking.rs
index ff841707a7..9af86cf17c 100644
--- a/rust/core/src/non_blocking.rs
+++ b/rust/core/src/non_blocking.rs
@@ -22,7 +22,21 @@ use std::collections::HashSet;
 
 use crate::error::Result;
 use crate::options::{self, *};
-use crate::PartitionedResult;
+
+/// Each data partition is described by an opaque byte array and can be
+/// retrieved with [Connection::read_partition].
+pub type Partitions = Vec<Vec<u8>>;
+
+/// A partitioned result set as returned by [Statement::execute_partitions].
+#[derive(Debug, PartialEq, Eq)]
+pub struct PartitionedResult {
+    /// The result partitions.
+    pub partitions: Partitions,
+    /// The schema of the result set.
+    pub schema: Schema,
+    /// The number of rows affected if known, else -1.
+    pub rows_affected: i64,
+}
 
 /// Ability to configure an object by setting/getting options.
 #[trait_variant::make(AsyncOptionable: Send)]
@@ -362,7 +376,10 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
     /// # Arguments
     ///
     /// - `partition` - The partition descriptor.
-    async fn read_partition(&self, partition: &[u8]) -> Result<impl RecordBatchReader + Send>;
+    async fn read_partition(
+        &self,
+        partition: &[u8],
+    ) -> Result<impl RecordBatchReader + Send + 'static>;
 }
 
 /// A handle to an async ADBC statement.
diff --git a/rust/driver/datafusion/src/lib.rs b/rust/driver/datafusion/src/lib.rs
index 3933f885c1..6fac98e860 100644
--- a/rust/driver/datafusion/src/lib.rs
+++ b/rust/driver/datafusion/src/lib.rs
@@ -16,8 +16,7 @@
 // under the License.
 #![allow(refining_impl_trait)]
 
-mod syncify;
-
+use adbc_core::executor::AsyncExecutor;
 use adbc_core::non_blocking::{
     AsyncConnection, AsyncDatabase, AsyncDriver, AsyncStatement, LocalAsyncOptionable,
 };
@@ -950,5 +949,26 @@ impl AsyncStatement for DataFusionStatement {
     }
 }
 
+pub struct TokioRuntime(tokio::runtime::Runtime);
+
+impl AsyncExecutor for TokioRuntime {
+    type Config = ();
+    type Error = std::io::Error;
+
+    fn new(_: Self::Config) -> std::result::Result<Self, Self::Error> {
+        tokio::runtime::Builder::new_multi_thread()
+            .enable_all()
+            .build()
+            .map(TokioRuntime)
+    }
+
+    fn block_on<F: Future>(&self, future: F) -> F::Output {
+        self.0.block_on(future)
+    }
+}
+
 #[cfg(feature = "ffi")]
-adbc_ffi::export_driver!(DataFusionDriverInit, crate::syncify::SyncDataFusionDriver);
+adbc_ffi::export_driver!(
+    DataFusionDriverInit,
+    adbc_core::blocking::SyncDriverWrapper::<TokioRuntime, DataFusionDriver>
+);
diff --git a/rust/driver/datafusion/src/syncify.rs b/rust/driver/datafusion/src/syncify.rs
deleted file mode 100644
index 189eb35128..0000000000
--- a/rust/driver/datafusion/src/syncify.rs
+++ /dev/null
@@ -1,356 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-#![allow(dead_code)]
-use std::sync::Arc;
-
-use adbc_core::{
-    non_blocking::{
-        AsyncConnection, AsyncDatabase, AsyncDriver, AsyncStatement, LocalAsyncOptionable,
-    },
-    options::{OptionConnection, OptionDatabase, OptionStatement},
-    Connection, Database, Driver, Optionable, Statement,
-};
-use tokio::runtime::Runtime;
-
-use crate::{DataFusionConnection, DataFusionDatabase, DataFusionDriver, DataFusionStatement};
-
-pub struct SyncDataFusionDriver {
-    driver: DataFusionDriver,
-    rt: Arc<Runtime>,
-}
-
-pub struct SyncDataFusionDatabase {
-    db: DataFusionDatabase,
-    rt: Arc<Runtime>,
-}
-
-pub struct SyncDataFusionConnection {
-    conn: DataFusionConnection,
-    rt: Arc<Runtime>,
-}
-
-pub struct SyncDataFusionStatement {
-    stmt: DataFusionStatement,
-    rt: Arc<Runtime>,
-}
-
-impl Default for SyncDataFusionDriver {
-    fn default() -> Self {
-        Self {
-            driver: Default::default(),
-            rt: Arc::new(
-                tokio::runtime::Builder::new_multi_thread()
-                    .enable_all()
-                    .build()
-                    .unwrap(),
-            ),
-        }
-    }
-}
-
-impl Driver for SyncDataFusionDriver {
-    type DatabaseType = SyncDataFusionDatabase;
-
-    fn new_database(&mut self) -> adbc_core::error::Result<Self::DatabaseType> {
-        let db = self.rt.block_on(self.driver.new_database())?;
-
-        Ok(SyncDataFusionDatabase {
-            db,
-            rt: self.rt.clone(),
-        })
-    }
-
-    fn new_database_with_opts(
-        &mut self,
-        opts: impl IntoIterator<
-            Item = (
-                adbc_core::options::OptionDatabase,
-                adbc_core::options::OptionValue,
-            ),
-        >,
-    ) -> adbc_core::error::Result<Self::DatabaseType> {
-        let db = self.rt.block_on(
-            self.driver
-                .new_database_with_opts(opts.into_iter().collect()),
-        )?;
-
-        Ok(SyncDataFusionDatabase {
-            db,
-            rt: self.rt.clone(),
-        })
-    }
-}
-
-impl Optionable for SyncDataFusionDatabase {
-    type Option = OptionDatabase;
-
-    fn set_option(
-        &mut self,
-        key: Self::Option,
-        value: adbc_core::options::OptionValue,
-    ) -> adbc_core::error::Result<()> {
-        self.rt.block_on(self.db.set_option(key, value))
-    }
-
-    fn get_option_string(&self, key: Self::Option) -> adbc_core::error::Result<String> {
-        self.rt.block_on(self.db.get_option_string(key))
-    }
-
-    fn get_option_bytes(&self, key: Self::Option) -> adbc_core::error::Result<Vec<u8>> {
-        self.rt.block_on(self.db.get_option_bytes(key))
-    }
-
-    fn get_option_int(&self, key: Self::Option) -> adbc_core::error::Result<i64> {
-        self.rt.block_on(self.db.get_option_int(key))
-    }
-
-    fn get_option_double(&self, key: Self::Option) -> adbc_core::error::Result<f64> {
-        self.rt.block_on(self.db.get_option_double(key))
-    }
-}
-
-impl Database for SyncDataFusionDatabase {
-    type ConnectionType = SyncDataFusionConnection;
-
-    fn new_connection(&self) -> adbc_core::error::Result<Self::ConnectionType> {
-        let conn = self.rt.block_on(self.db.new_connection())?;
-
-        Ok(SyncDataFusionConnection {
-            conn,
-            rt: self.rt.clone(),
-        })
-    }
-
-    fn new_connection_with_opts(
-        &self,
-        opts: impl IntoIterator<
-            Item = (
-                adbc_core::options::OptionConnection,
-                adbc_core::options::OptionValue,
-            ),
-        >,
-    ) -> adbc_core::error::Result<Self::ConnectionType> {
-        let conn = self
-            .rt
-            .block_on(self.db.new_connection_with_opts(opts.into_iter().collect()))?;
-
-        Ok(SyncDataFusionConnection {
-            conn,
-            rt: self.rt.clone(),
-        })
-    }
-}
-
-impl Optionable for SyncDataFusionConnection {
-    type Option = OptionConnection;
-
-    fn set_option(
-        &mut self,
-        key: Self::Option,
-        value: adbc_core::options::OptionValue,
-    ) -> adbc_core::error::Result<()> {
-        self.rt.block_on(self.conn.set_option(key, value))
-    }
-
-    fn get_option_string(&self, key: Self::Option) -> adbc_core::error::Result<String> {
-        self.rt.block_on(self.conn.get_option_string(key))
-    }
-
-    fn get_option_bytes(&self, key: Self::Option) -> adbc_core::error::Result<Vec<u8>> {
-        self.rt.block_on(self.conn.get_option_bytes(key))
-    }
-
-    fn get_option_int(&self, key: Self::Option) -> adbc_core::error::Result<i64> {
-        self.rt.block_on(self.conn.get_option_int(key))
-    }
-
-    fn get_option_double(&self, key: Self::Option) -> adbc_core::error::Result<f64> {
-        self.rt.block_on(self.conn.get_option_double(key))
-    }
-}
-
-impl Connection for SyncDataFusionConnection {
-    type StatementType = SyncDataFusionStatement;
-
-    fn new_statement(&mut self) -> adbc_core::error::Result<Self::StatementType> {
-        let stmt = self.rt.block_on(self.conn.new_statement())?;
-
-        Ok(SyncDataFusionStatement {
-            stmt,
-            rt: self.rt.clone(),
-        })
-    }
-
-    fn cancel(&mut self) -> adbc_core::error::Result<()> {
-        self.rt.block_on(self.conn.cancel())
-    }
-
-    fn get_info(
-        &self,
-        codes: Option<std::collections::HashSet<adbc_core::options::InfoCode>>,
-    ) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
-        self.rt.block_on(self.conn.get_info(codes))
-    }
-
-    fn get_objects(
-        &self,
-        depth: adbc_core::options::ObjectDepth,
-        catalog: Option<&str>,
-        db_schema: Option<&str>,
-        table_name: Option<&str>,
-        table_type: Option<Vec<&str>>,
-        column_name: Option<&str>,
-    ) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
-        self.rt.block_on(self.conn.get_objects(
-            depth,
-            catalog,
-            db_schema,
-            table_name,
-            table_type,
-            column_name,
-        ))
-    }
-
-    fn get_table_schema(
-        &self,
-        catalog: Option<&str>,
-        db_schema: Option<&str>,
-        table_name: &str,
-    ) -> adbc_core::error::Result<arrow_schema::Schema> {
-        self.rt
-            .block_on(self.conn.get_table_schema(catalog, db_schema, table_name))
-    }
-
-    fn get_table_types(
-        &self,
-    ) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
-        self.rt.block_on(self.conn.get_table_types())
-    }
-
-    fn get_statistic_names(
-        &self,
-    ) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
-        self.rt.block_on(self.conn.get_statistic_names())
-    }
-
-    fn get_statistics(
-        &self,
-        catalog: Option<&str>,
-        db_schema: Option<&str>,
-        table_name: Option<&str>,
-        approximate: bool,
-    ) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
-        self.rt.block_on(
-            self.conn
-                .get_statistics(catalog, db_schema, table_name, approximate),
-        )
-    }
-
-    fn commit(&mut self) -> adbc_core::error::Result<()> {
-        self.rt.block_on(self.conn.commit())
-    }
-
-    fn rollback(&mut self) -> adbc_core::error::Result<()> {
-        self.rt.block_on(self.conn.rollback())
-    }
-
-    fn read_partition(
-        &self,
-        partition: impl AsRef<[u8]>,
-    ) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
-        self.rt
-            .block_on(self.conn.read_partition(partition.as_ref()))
-    }
-}
-
-impl Optionable for SyncDataFusionStatement {
-    type Option = OptionStatement;
-
-    fn set_option(
-        &mut self,
-        key: Self::Option,
-        value: adbc_core::options::OptionValue,
-    ) -> adbc_core::error::Result<()> {
-        self.rt.block_on(self.stmt.set_option(key, value))
-    }
-
-    fn get_option_string(&self, key: Self::Option) -> adbc_core::error::Result<String> {
-        self.rt.block_on(self.stmt.get_option_string(key))
-    }
-
-    fn get_option_bytes(&self, key: Self::Option) -> adbc_core::error::Result<Vec<u8>> {
-        self.rt.block_on(self.stmt.get_option_bytes(key))
-    }
-
-    fn get_option_int(&self, key: Self::Option) -> adbc_core::error::Result<i64> {
-        self.rt.block_on(self.stmt.get_option_int(key))
-    }
-
-    fn get_option_double(&self, key: Self::Option) -> adbc_core::error::Result<f64> {
-        self.rt.block_on(self.stmt.get_option_double(key))
-    }
-}
-
-impl Statement for SyncDataFusionStatement {
-    fn bind(&mut self, batch: arrow_array::RecordBatch) -> adbc_core::error::Result<()> {
-        self.rt.block_on(self.stmt.bind(batch))
-    }
-
-    fn bind_stream(
-        &mut self,
-        reader: Box<dyn arrow_array::RecordBatchReader + Send>,
-    ) -> adbc_core::error::Result<()> {
-        self.rt.block_on(self.stmt.bind_stream(reader))
-    }
-
-    fn execute(&mut self) -> adbc_core::error::Result<impl arrow_array::RecordBatchReader + Send> {
-        self.rt.block_on(self.stmt.execute())
-    }
-
-    fn execute_update(&mut self) -> adbc_core::error::Result<Option<i64>> {
-        self.rt.block_on(self.stmt.execute_update())
-    }
-
-    fn execute_schema(&mut self) -> adbc_core::error::Result<arrow_schema::Schema> {
-        self.rt.block_on(self.stmt.execute_schema())
-    }
-
-    fn execute_partitions(&mut self) -> adbc_core::error::Result<adbc_core::PartitionedResult> {
-        self.rt.block_on(self.stmt.execute_partitions())
-    }
-
-    fn get_parameter_schema(&self) -> adbc_core::error::Result<arrow_schema::Schema> {
-        self.rt.block_on(self.stmt.get_parameter_schema())
-    }
-
-    fn prepare(&mut self) -> adbc_core::error::Result<()> {
-        self.rt.block_on(self.stmt.prepare())
-    }
-
-    fn set_sql_query(&mut self, query: impl AsRef<str>) -> adbc_core::error::Result<()> {
-        self.rt.block_on(self.stmt.set_sql_query(query.as_ref()))
-    }
-
-    fn set_substrait_plan(&mut self, plan: impl AsRef<[u8]>) -> adbc_core::error::Result<()> {
-        self.rt
-            .block_on(self.stmt.set_substrait_plan(plan.as_ref()))
-    }
-
-    fn cancel(&mut self) -> adbc_core::error::Result<()> {
-        self.rt.block_on(self.stmt.cancel())
-    }
-}
diff --git a/rust/driver/dummy/src/lib.rs b/rust/driver/dummy/src/lib.rs
index 4ab708afdf..56199e7a72 100644
--- a/rust/driver/dummy/src/lib.rs
+++ b/rust/driver/dummy/src/lib.rs
@@ -29,12 +29,13 @@ use arrow_buffer::{OffsetBuffer, ScalarBuffer};
 use arrow_schema::{ArrowError, DataType, Field, Schema, SchemaRef, UnionFields};
 
 use adbc_core::{
+    blocking::{Connection, Database, Driver, Optionable, Statement},
     constants,
     error::{Error, Result, Status},
     options::{
         InfoCode, ObjectDepth, OptionConnection, OptionDatabase, OptionStatement, OptionValue,
     },
-    schemas, Connection, Database, Driver, Optionable, PartitionedResult, Statement,
+    schemas, PartitionedResult,
 };
 
 #[derive(Debug)]
@@ -783,7 +784,7 @@ impl Connection for DummyConnection {
         Ok(reader)
     }
 
-    fn read_partition(&self, _partition: impl AsRef<[u8]>) -> Result<impl RecordBatchReader> {
+    fn read_partition(&self, _partition: &[u8]) -> Result<impl RecordBatchReader> {
         let batch = get_table_data();
         let reader = SingleBatchReader::new(batch);
         Ok(reader)
diff --git a/rust/driver/dummy/tests/driver_exporter_dummy.rs b/rust/driver/dummy/tests/driver_exporter_dummy.rs
index a5869c0555..1e97b7ec74 100644
--- a/rust/driver/dummy/tests/driver_exporter_dummy.rs
+++ b/rust/driver/dummy/tests/driver_exporter_dummy.rs
@@ -30,8 +30,10 @@ use adbc_core::options::{
     AdbcVersion, InfoCode, IngestMode, IsolationLevel, ObjectDepth, OptionConnection,
     OptionDatabase, OptionStatement,
 };
-use adbc_core::Statement;
-use adbc_core::{schemas, Connection, Database, Driver, Optionable};
+use adbc_core::{
+    blocking::{Connection, Database, Driver, Optionable, Statement},
+    schemas,
+};
 use adbc_driver_manager::{ManagedConnection, ManagedDatabase, ManagedDriver, ManagedStatement};
 
 use adbc_dummy::{DummyConnection, DummyDatabase, DummyDriver, DummyStatement, SingleBatchReader};
diff --git a/rust/driver/snowflake/src/connection.rs b/rust/driver/snowflake/src/connection.rs
index cc0ba51d94..cee10b4867 100644
--- a/rust/driver/snowflake/src/connection.rs
+++ b/rust/driver/snowflake/src/connection.rs
@@ -22,9 +22,9 @@
 use std::collections::HashSet;
 
 use adbc_core::{
+    blocking::Optionable,
     error::Result,
     options::{InfoCode, OptionConnection, OptionValue},
-    Optionable,
 };
 use adbc_driver_manager::ManagedConnection;
 use arrow_array::RecordBatchReader;
@@ -63,7 +63,7 @@ impl Optionable for Connection {
     }
 }
 
-impl adbc_core::Connection for Connection {
+impl adbc_core::blocking::Connection for Connection {
     type StatementType = Statement;
 
     fn new_statement(&mut self) -> Result<Self::StatementType> {
@@ -133,7 +133,7 @@ impl adbc_core::Connection for Connection {
         self.0.rollback()
     }
 
-    fn read_partition(&self, partition: impl AsRef<[u8]>) -> Result<impl RecordBatchReader + Send> {
+    fn read_partition(&self, partition: &[u8]) -> Result<impl RecordBatchReader + Send> {
         self.0.read_partition(partition)
     }
 }
diff --git a/rust/driver/snowflake/src/connection/builder.rs b/rust/driver/snowflake/src/connection/builder.rs
index fbc2b8cfba..62ce7abb7c 100644
--- a/rust/driver/snowflake/src/connection/builder.rs
+++ b/rust/driver/snowflake/src/connection/builder.rs
@@ -22,9 +22,9 @@
 use std::fmt;
 
 use adbc_core::{
+    blocking::Database as _,
     error::Result,
     options::{OptionConnection, OptionValue},
-    Database as _,
 };
 
 #[cfg(feature = "env")]
diff --git a/rust/driver/snowflake/src/database.rs b/rust/driver/snowflake/src/database.rs
index 48715a78e5..14930f7223 100644
--- a/rust/driver/snowflake/src/database.rs
+++ b/rust/driver/snowflake/src/database.rs
@@ -22,9 +22,9 @@
 use std::{collections::HashSet, ffi::c_int, sync::Arc};
 
 use adbc_core::{
+    blocking::{Connection as _, Database as _, Optionable},
     error::{Error, Result, Status},
     options::{AdbcVersion, InfoCode, OptionConnection, OptionDatabase, OptionValue},
-    Connection as _, Database as _, Optionable,
 };
 use adbc_driver_manager::ManagedDatabase;
 use arrow_array::{
@@ -165,7 +165,7 @@ impl Optionable for Database {
     }
 }
 
-impl adbc_core::Database for Database {
+impl adbc_core::blocking::Database for Database {
     type ConnectionType = Connection;
 
     fn new_connection(&self) -> Result<Self::ConnectionType> {
diff --git a/rust/driver/snowflake/src/database/builder.rs b/rust/driver/snowflake/src/database/builder.rs
index 05dd921e9f..d79c6b3bc7 100644
--- a/rust/driver/snowflake/src/database/builder.rs
+++ b/rust/driver/snowflake/src/database/builder.rs
@@ -25,9 +25,9 @@ use std::env;
 use std::{fmt, path::PathBuf, str::FromStr, time::Duration};
 
 use adbc_core::{
+    blocking::Driver as _,
     error::{Error, Result, Status},
     options::{OptionDatabase, OptionValue},
-    Driver as _,
 };
 use url::{Host, Url};
 
diff --git a/rust/driver/snowflake/src/driver.rs b/rust/driver/snowflake/src/driver.rs
index 7467ae872c..546f2a6289 100644
--- a/rust/driver/snowflake/src/driver.rs
+++ b/rust/driver/snowflake/src/driver.rs
@@ -153,7 +153,7 @@ impl Driver {
     }
 }
 
-impl adbc_core::Driver for Driver {
+impl adbc_core::blocking::Driver for Driver {
     type DatabaseType = Database;
 
     fn new_database(&mut self) -> Result<Self::DatabaseType> {
diff --git a/rust/driver/snowflake/src/statement.rs b/rust/driver/snowflake/src/statement.rs
index eb41d1108f..acfaf1b9ff 100644
--- a/rust/driver/snowflake/src/statement.rs
+++ b/rust/driver/snowflake/src/statement.rs
@@ -20,9 +20,10 @@
 //!
 
 use adbc_core::{
+    blocking::Optionable,
     error::Result,
     options::{OptionStatement, OptionValue},
-    Optionable, PartitionedResult,
+    PartitionedResult,
 };
 use adbc_driver_manager::ManagedStatement;
 use arrow_array::{RecordBatch, RecordBatchReader};
@@ -55,7 +56,7 @@ impl Optionable for Statement {
     }
 }
 
-impl adbc_core::Statement for Statement {
+impl adbc_core::blocking::Statement for Statement {
     fn bind(&mut self, batch: RecordBatch) -> Result<()> {
         self.0.bind(batch)
     }
diff --git a/rust/driver/snowflake/tests/driver.rs b/rust/driver/snowflake/tests/driver.rs
index a5eaec7561..9b8680a38d 100644
--- a/rust/driver/snowflake/tests/driver.rs
+++ b/rust/driver/snowflake/tests/driver.rs
@@ -37,9 +37,9 @@ mod tests {
     use std::{collections::HashSet, ops::Deref, sync::LazyLock};
 
     use adbc_core::{
+        blocking::{Connection as _, Statement as _},
         error::{Error, Result},
         options::AdbcVersion,
-        Connection as _, Statement as _,
     };
     use adbc_snowflake::{connection, database, driver, Connection, Database, Driver, Statement};
     use arrow_array::{cast::AsArray, types::Decimal128Type};
diff --git a/rust/driver_manager/src/lib.rs b/rust/driver_manager/src/lib.rs
index 173b60d06d..345fbc815e 100644
--- a/rust/driver_manager/src/lib.rs
+++ b/rust/driver_manager/src/lib.rs
@@ -119,12 +119,12 @@ use arrow_array::{Array, RecordBatch, RecordBatchReader, StructArray};
 use toml::de::DeTable;
 
 use adbc_core::{
+    blocking::{Connection, Database, Driver, Optionable, Statement},
     constants,
     error::{AdbcStatusCode, Error, Result, Status},
     options::{self, AdbcVersion, InfoCode, OptionDatabase, OptionValue},
-    Connection, Database, Driver, LoadFlags, Optionable, PartitionedResult, Statement,
-    LOAD_FLAG_ALLOW_RELATIVE_PATHS, LOAD_FLAG_SEARCH_ENV, LOAD_FLAG_SEARCH_SYSTEM,
-    LOAD_FLAG_SEARCH_USER,
+    LoadFlags, PartitionedResult, LOAD_FLAG_ALLOW_RELATIVE_PATHS, LOAD_FLAG_SEARCH_ENV,
+    LOAD_FLAG_SEARCH_SYSTEM, LOAD_FLAG_SEARCH_USER,
 };
 use adbc_ffi::driver_method;
 
@@ -1473,13 +1473,12 @@ impl Connection for ManagedConnection {
         Ok(reader)
     }
 
-    fn read_partition(&self, partition: impl AsRef<[u8]>) -> Result<impl RecordBatchReader> {
+    fn read_partition(&self, partition: &[u8]) -> Result<impl RecordBatchReader> {
         let mut stream = FFI_ArrowArrayStream::empty();
         let driver = self.ffi_driver();
         let mut connection = self.inner.connection.lock().unwrap();
         let mut error = adbc_ffi::FFI_AdbcError::with_driver(driver);
         let method = driver_method!(driver, ConnectionReadPartition);
-        let partition = partition.as_ref();
         let status = unsafe {
             method(
                 connection.deref_mut(),
diff --git a/rust/driver_manager/tests/common/mod.rs b/rust/driver_manager/tests/common/mod.rs
index 28df83f104..31b8293824 100644
--- a/rust/driver_manager/tests/common/mod.rs
+++ b/rust/driver_manager/tests/common/mod.rs
@@ -19,12 +19,12 @@ use std::collections::HashSet;
 use std::ops::Deref;
 use std::sync::Arc;
 
+use adbc_core::blocking::{Connection, Database, Driver, Optionable, Statement};
 use adbc_core::error::Status;
 use adbc_core::options::{
     InfoCode, IngestMode, ObjectDepth, OptionConnection, OptionDatabase, OptionStatement,
 };
 use adbc_core::schemas;
-use adbc_core::{Connection, Database, Driver, Optionable, Statement};
 use adbc_driver_manager::{ManagedConnection, ManagedDatabase, ManagedDriver, ManagedStatement};
 
 use arrow_array::{
diff --git a/rust/driver_manager/tests/driver_manager_sqlite.rs b/rust/driver_manager/tests/driver_manager_sqlite.rs
index b00f9a555a..e155f363d1 100644
--- a/rust/driver_manager/tests/driver_manager_sqlite.rs
+++ b/rust/driver_manager/tests/driver_manager_sqlite.rs
@@ -17,9 +17,10 @@
 
 use arrow_schema::{Field, Schema};
 
+use adbc_core::blocking::{Connection, Database, Driver, Optionable, Statement};
+use adbc_core::error::Status;
 use adbc_core::options::{AdbcVersion, OptionConnection, OptionDatabase};
-use adbc_core::{error::Status, Driver, Optionable};
-use adbc_core::{Connection, Database, Statement, LOAD_FLAG_DEFAULT};
+use adbc_core::LOAD_FLAG_DEFAULT;
 use adbc_driver_manager::{ManagedDatabase, ManagedDriver};
 
 mod common;
diff --git a/rust/ffi/src/driver_exporter.rs b/rust/ffi/src/driver_exporter.rs
index c142121bf1..eaefc6033b 100644
--- a/rust/ffi/src/driver_exporter.rs
+++ b/rust/ffi/src/driver_exporter.rs
@@ -29,10 +29,10 @@ use super::{
     types::ErrorPrivateData, utils::get_opt_name, FFI_AdbcConnection, FFI_AdbcDatabase,
     FFI_AdbcDriver, FFI_AdbcError, FFI_AdbcErrorDetail, FFI_AdbcPartitions, FFI_AdbcStatement,
 };
+use adbc_core::blocking::{Connection, Database, Driver, Optionable, Statement};
 use adbc_core::constants::ADBC_STATUS_OK;
 use adbc_core::error::{AdbcStatusCode, Error, Result, Status};
 use adbc_core::options::{InfoCode, ObjectDepth, OptionConnection, OptionDatabase, OptionValue};
-use adbc_core::{Connection, Database, Driver, Optionable, Statement};
 
 type DatabaseType<DriverType> = <DriverType as Driver>::DatabaseType;
 type ConnectionType<DriverType> =

From 4ed60baae0f2012b1b23197e19b466f6c126f515 Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Fri, 14 Nov 2025 17:09:15 +0300
Subject: [PATCH 06/14] fix: docs

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/core/src/lib.rs                          |  8 ++++----
 rust/core/src/non_blocking.rs                 |  4 ++--
 rust/core/src/options.rs                      | 14 +++++++-------
 rust/core/src/schemas.rs                      | 10 +++++-----
 rust/driver/datafusion/README.md              |  4 ++--
 rust/driver/snowflake/README.md               |  2 +-
 rust/driver/snowflake/src/database/builder.rs |  2 +-
 rust/driver_manager/src/lib.rs                |  2 +-
 rust/ffi/src/lib.rs                           |  2 +-
 9 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/rust/core/src/lib.rs b/rust/core/src/lib.rs
index 871d8d9cc4..cf790f9ede 100644
--- a/rust/core/src/lib.rs
+++ b/rust/core/src/lib.rs
@@ -31,10 +31,10 @@
 //! # Native Rust drivers
 //!
 //! Native Rust drivers will implement the abstract API consisting of the traits:
-//! - [Driver]
-//! - [Database]
-//! - [Connection]
-//! - [Statement]
+//! - [AsyncDriver]
+//! - [AsyncDatabase]
+//! - [AsyncConnection]
+//! - [AsyncStatement]
 //!
 //! For drivers implemented in Rust, using these will be more efficient and
 //! safe, since it avoids the overhead of going through C FFI.
diff --git a/rust/core/src/non_blocking.rs b/rust/core/src/non_blocking.rs
index 9af86cf17c..3f6c950cbe 100644
--- a/rust/core/src/non_blocking.rs
+++ b/rust/core/src/non_blocking.rs
@@ -24,10 +24,10 @@ use crate::error::Result;
 use crate::options::{self, *};
 
 /// Each data partition is described by an opaque byte array and can be
-/// retrieved with [Connection::read_partition].
+/// retrieved with [AsyncConnection::read_partition].
 pub type Partitions = Vec<Vec<u8>>;
 
-/// A partitioned result set as returned by [Statement::execute_partitions].
+/// A partitioned result set as returned by [AsyncStatement::execute_partitions].
 #[derive(Debug, PartialEq, Eq)]
 pub struct PartitionedResult {
     /// The result partitions.
diff --git a/rust/core/src/options.rs b/rust/core/src/options.rs
index 91c0f06b7d..dbf7f73e9c 100644
--- a/rust/core/src/options.rs
+++ b/rust/core/src/options.rs
@@ -218,7 +218,7 @@ impl TryFrom<u32> for InfoCode {
     }
 }
 
-/// Depth parameter for [get_objects][crate::Connection::get_objects] method.
+/// Depth parameter for [get_objects][crate::AsyncConnection::get_objects] method.
 #[derive(Debug)]
 pub enum ObjectDepth {
     /// Catalogs, schemas, tables, and columns.
@@ -374,19 +374,19 @@ pub enum OptionStatement {
     Temporary,
     /// Whether query execution is nonblocking. By default, execution is blocking.
     ///
-    /// When enabled, [execute_partitions][crate::Statement::execute_partitions]
+    /// When enabled, [execute_partitions][crate::AsyncStatement::execute_partitions]
     /// will return partitions as soon as they are available, instead of returning
     /// them all at the end. When there are no more to return, it will return an
-    /// empty set of partitions. The methods [execute][crate::Statement::execute],
-    /// [execute_schema][crate::Statement::execute_schema] and
-    /// [execute_update][crate::Statement::execute_update] are not affected.
+    /// empty set of partitions. The methods [execute][crate::AsyncStatement::execute],
+    /// [execute_schema][crate::AsyncStatement::execute_schema] and
+    /// [execute_update][crate::AsyncStatement::execute_update] are not affected.
     ///
     /// # Since
     ///
     /// ADBC API revision 1.1.0
     Incremental,
     /// Get the progress of a query. It's a read-only option that should be
-    /// read with [get_option_double][crate::Optionable::get_option_double].
+    /// read with [get_option_double][crate::AsyncOptionable::get_option_double].
     ///
     /// The value is not necessarily in any particular range or have any
     /// particular units. For example, it might be a percentage, bytes of data,
@@ -400,7 +400,7 @@ pub enum OptionStatement {
     /// ADBC API revision 1.1.0
     Progress,
     /// Get the maximum progress of a query. It's a read-only option that should be
-    /// read with [get_option_double][crate::Optionable::get_option_double].
+    /// read with [get_option_double][crate::AsyncOptionable::get_option_double].
     ///
     /// This is the value of [OptionStatement::Progress] for a completed query.
     /// If not supported, or if the value is nonpositive, then the maximum is not
diff --git a/rust/core/src/schemas.rs b/rust/core/src/schemas.rs
index 156ee1aac6..4dfdc2dee6 100644
--- a/rust/core/src/schemas.rs
+++ b/rust/core/src/schemas.rs
@@ -21,7 +21,7 @@ use std::sync::{Arc, LazyLock};
 
 use arrow_schema::{DataType, Field, Schema, SchemaRef, UnionFields, UnionMode};
 
-/// Schema of the data returned by [get_table_types][crate::Connection::get_table_types].
+/// Schema of the data returned by [get_table_types][crate::AsyncConnection::get_table_types].
 pub static GET_TABLE_TYPES_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     Arc::new(Schema::new(vec![Field::new(
         "table_type",
@@ -30,7 +30,7 @@ pub static GET_TABLE_TYPES_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     )]))
 });
 
-/// Schema of the data returned by [get_info][crate::Connection::get_info].
+/// Schema of the data returned by [get_info][crate::AsyncConnection::get_info].
 pub static GET_INFO_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     let info_schema = DataType::Union(
         UnionFields::new(
@@ -64,7 +64,7 @@ pub static GET_INFO_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     ]))
 });
 
-/// Schema of data returned by [get_statistic_names][crate::Connection::get_statistic_names].
+/// Schema of data returned by [get_statistic_names][crate::AsyncConnection::get_statistic_names].
 pub static GET_STATISTIC_NAMES_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     Arc::new(Schema::new(vec![
         Field::new("statistic_name", DataType::Utf8, false),
@@ -114,7 +114,7 @@ pub static STATISTICS_DB_SCHEMA_SCHEMA: LazyLock<DataType> = LazyLock::new(|| {
     )
 });
 
-/// Schema of data returned by [get_statistics][crate::Connection::get_statistics].
+/// Schema of data returned by [get_statistics][crate::AsyncConnection::get_statistics].
 pub static GET_STATISTICS_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     Arc::new(Schema::new(vec![
         Field::new("catalog_name", DataType::Utf8, true),
@@ -219,7 +219,7 @@ pub static OBJECTS_DB_SCHEMA_SCHEMA: LazyLock<DataType> = LazyLock::new(|| {
     )
 });
 
-/// Schema of data returned by [get_objects][crate::Connection::get_objects].
+/// Schema of data returned by [get_objects][crate::AsyncConnection::get_objects].
 pub static GET_OBJECTS_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     Arc::new(Schema::new(vec![
         Field::new("catalog_name", DataType::Utf8, true),
diff --git a/rust/driver/datafusion/README.md b/rust/driver/datafusion/README.md
index ed5bb9d4db..83a7978afd 100644
--- a/rust/driver/datafusion/README.md
+++ b/rust/driver/datafusion/README.md
@@ -27,10 +27,10 @@
 
 ## Example Usage
 
-```
+```rust
 use adbc_core::driver_manager::ManagedDriver;
 use adbc_core::options::AdbcVersion;
-use adbc_core::{Connection, Database, Driver, Statement};
+use adbc_core::blocking::{Connection, Database, Driver, Statement};
 use arrow_cast::pretty::print_batches;
 use arrow_array::RecordBatch;
 
diff --git a/rust/driver/snowflake/README.md b/rust/driver/snowflake/README.md
index 1146036625..6ee962be73 100644
--- a/rust/driver/snowflake/README.md
+++ b/rust/driver/snowflake/README.md
@@ -31,7 +31,7 @@ driver, based on the
 ## Example
 
 ```rust,no_run
-use adbc_core::{Connection, Statement};
+use adbc_core::blocking::{Connection, Statement};
 use adbc_snowflake::{connection, database, Driver};
 use arrow_array::{cast::AsArray, types::Decimal128Type};
 
diff --git a/rust/driver/snowflake/src/database/builder.rs b/rust/driver/snowflake/src/database/builder.rs
index d79c6b3bc7..a320dd3da0 100644
--- a/rust/driver/snowflake/src/database/builder.rs
+++ b/rust/driver/snowflake/src/database/builder.rs
@@ -490,7 +490,7 @@ impl Builder {
     pub const CLIENT_STORE_TEMP_CREDS_ENV: &str =
         "ADBC_SNOWFLAKE_SQL_CLIENT_OPTION_STORE_TEMP_CREDS";
 
-    /// See [`Self::]
+    /// See [`Self::client_identity_provider`]
     pub const CLIENT_IDENTITY_PROVIDER_ENV: &str =
         "ADBC_SNOWFLAKE_SQL_CLIENT_OPTION_IDENTITY_PROVIDER";
 
diff --git a/rust/driver_manager/src/lib.rs b/rust/driver_manager/src/lib.rs
index 345fbc815e..f37b62d03d 100644
--- a/rust/driver_manager/src/lib.rs
+++ b/rust/driver_manager/src/lib.rs
@@ -50,7 +50,7 @@
 //! # use arrow_select::concat::concat_batches;
 //! # use adbc_core::{
 //! #     options::{AdbcVersion, OptionDatabase, OptionStatement},
-//! #     Connection, Database, Driver, Statement, Optionable
+//! #     blocking::{Connection, Database, Driver, Statement, Optionable}
 //! # };
 //! # use adbc_driver_manager::ManagedDriver;
 //! # fn main() -> Result<(), Box<dyn std::error::Error>> {
diff --git a/rust/ffi/src/lib.rs b/rust/ffi/src/lib.rs
index 68ae30375b..bf95a8c403 100644
--- a/rust/ffi/src/lib.rs
+++ b/rust/ffi/src/lib.rs
@@ -34,7 +34,7 @@
 //!
 //! The driver exporter allows exposing native Rust drivers as C drivers to be
 //! used by other languages via their own driver manager. Once you have an
-//! implementation of [adbc_core::Driver], provided that it also implements [Default], you
+//! implementation of [adbc_core::blocking::Driver], provided that it also implements [Default], you
 //! can build it as an object file implementing the C API with the
 //! [export_driver] macro.
 

From 5f7e867e5889c2ba818e1b32bcae1e5a23a16405 Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Wed, 26 Nov 2025 11:47:08 +0300
Subject: [PATCH 07/14] changes: remove trait-variant deps

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/Cargo.lock                     |  12 -
 rust/Cargo.toml                     |   1 -
 rust/core/Cargo.toml                |   1 -
 rust/core/src/blocking.rs           |   5 +-
 rust/core/src/lib.rs                |  17 +-
 rust/core/src/non_blocking.rs       | 475 +-------------------
 rust/core/src/non_blocking/local.rs | 473 +++++++++++++++++++
 rust/core/src/non_blocking/send.rs  | 675 ++++++++++++++++++++++++++++
 rust/driver/datafusion/src/lib.rs   |  12 +-
 9 files changed, 1175 insertions(+), 496 deletions(-)
 create mode 100644 rust/core/src/non_blocking/local.rs
 create mode 100644 rust/core/src/non_blocking/send.rs

diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 734d87f49c..245b6cda53 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -8,7 +8,6 @@ version = "0.22.0"
 dependencies = [
  "arrow-array",
  "arrow-schema",
- "trait-variant",
 ]
 
 [[package]]
@@ -2665,17 +2664,6 @@ dependencies = [
  "once_cell",
 ]
 
-[[package]]
-name = "trait-variant"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70977707304198400eb4835a78f6a9f928bf41bba420deb8fdb175cd965d77a7"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "twox-hash"
 version = "2.1.1"
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index 957aa1f2d7..644769716d 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -43,4 +43,3 @@ arrow-array = { version = ">=53.1.0, <58", default-features = false, features =
 arrow-buffer = { version = ">=53.1.0, <58", default-features = false }
 arrow-schema = { version = ">=53.1.0, <58", default-features = false }
 arrow-select = { version = ">=53.1.0, <58", default-features = false }
-trait-variant = { version = "0.1.2" }
diff --git a/rust/core/Cargo.toml b/rust/core/Cargo.toml
index b7ce3cc28f..bd33bf57f5 100644
--- a/rust/core/Cargo.toml
+++ b/rust/core/Cargo.toml
@@ -36,7 +36,6 @@ default = []
 [dependencies]
 arrow-array.workspace = true
 arrow-schema.workspace = true
-trait-variant.workspace = true
 
 [package.metadata.docs.rs]
 all-features = true
diff --git a/rust/core/src/blocking.rs b/rust/core/src/blocking.rs
index 669422ebd5..65b53a43da 100644
--- a/rust/core/src/blocking.rs
+++ b/rust/core/src/blocking.rs
@@ -23,7 +23,6 @@ use arrow_schema::Schema;
 
 use crate::error::Result;
 use crate::executor::AsyncExecutor;
-use crate::non_blocking::PartitionedResult;
 use crate::options::{self, OptionConnection, OptionDatabase, OptionStatement, OptionValue};
 use crate::{
     LocalAsyncConnection, LocalAsyncDatabase, LocalAsyncDriver, LocalAsyncOptionable,
@@ -426,7 +425,7 @@ pub trait Statement: Optionable<Option = OptionStatement> {
     fn execute_schema(&mut self) -> Result<Schema>;
 
     /// Execute a statement and get the results as a partitioned result set.
-    fn execute_partitions(&mut self) -> Result<PartitionedResult>;
+    fn execute_partitions(&mut self) -> Result<crate::PartitionedResult>;
 
     /// Get the schema for bound parameters.
     ///
@@ -765,7 +764,7 @@ where
         self.executor.block_on(self.inner.execute_schema())
     }
 
-    fn execute_partitions(&mut self) -> Result<PartitionedResult> {
+    fn execute_partitions(&mut self) -> Result<crate::PartitionedResult> {
         self.executor.block_on(self.inner.execute_partitions())
     }
 
diff --git a/rust/core/src/lib.rs b/rust/core/src/lib.rs
index cf790f9ede..8e1a06a03e 100644
--- a/rust/core/src/lib.rs
+++ b/rust/core/src/lib.rs
@@ -47,6 +47,8 @@ pub mod non_blocking;
 pub mod options;
 pub mod schemas;
 
+pub use non_blocking::*;
+
 pub type LoadFlags = u32;
 
 pub const LOAD_FLAG_SEARCH_ENV: LoadFlags = 1 << 1;
@@ -58,4 +60,17 @@ pub const LOAD_FLAG_DEFAULT: LoadFlags = LOAD_FLAG_SEARCH_ENV
     | LOAD_FLAG_SEARCH_SYSTEM
     | LOAD_FLAG_ALLOW_RELATIVE_PATHS;
 
-pub use non_blocking::*;
+/// Each data partition is described by an opaque byte array and can be
+/// retrieved with [AsyncConnection::read_partition].
+pub type Partitions = Vec<Vec<u8>>;
+
+/// A partitioned result set as returned by [AsyncStatement::execute_partitions].
+#[derive(Debug, PartialEq, Eq)]
+pub struct PartitionedResult {
+    /// The result partitions.
+    pub partitions: Partitions,
+    /// The schema of the result set.
+    pub schema: arrow_schema::Schema,
+    /// The number of rows affected if known, else -1.
+    pub rows_affected: i64,
+}
diff --git a/rust/core/src/non_blocking.rs b/rust/core/src/non_blocking.rs
index 3f6c950cbe..41ac7c32d4 100644
--- a/rust/core/src/non_blocking.rs
+++ b/rust/core/src/non_blocking.rs
@@ -15,475 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow_array::{RecordBatch, RecordBatchReader};
-use arrow_schema::Schema;
+pub mod local;
+pub mod send;
 
-use std::collections::HashSet;
-
-use crate::error::Result;
-use crate::options::{self, *};
-
-/// Each data partition is described by an opaque byte array and can be
-/// retrieved with [AsyncConnection::read_partition].
-pub type Partitions = Vec<Vec<u8>>;
-
-/// A partitioned result set as returned by [AsyncStatement::execute_partitions].
-#[derive(Debug, PartialEq, Eq)]
-pub struct PartitionedResult {
-    /// The result partitions.
-    pub partitions: Partitions,
-    /// The schema of the result set.
-    pub schema: Schema,
-    /// The number of rows affected if known, else -1.
-    pub rows_affected: i64,
-}
-
-/// Ability to configure an object by setting/getting options.
-#[trait_variant::make(AsyncOptionable: Send)]
-pub trait LocalAsyncOptionable {
-    type Option: AsRef<str>;
-
-    /// Set a post-init option.
-    async fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()>;
-
-    /// Get a string option value by key.
-    async fn get_option_string(&self, key: Self::Option) -> Result<String>;
-
-    /// Get a bytes option value by key.
-    async fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>>;
-
-    /// Get an integer option value by key.
-    async fn get_option_int(&self, key: Self::Option) -> Result<i64>;
-
-    /// Get a float option value by key.
-    async fn get_option_double(&self, key: Self::Option) -> Result<f64>;
-}
-
-/// A handle to an async ADBC driver.
-#[trait_variant::make(AsyncDriver: Send)]
-pub trait LocalAsyncDriver {
-    type DatabaseType: LocalAsyncDatabase;
-
-    /// Allocate and initialize a new database without pre-init options.
-    async fn new_database(&mut self) -> Result<Self::DatabaseType>;
-
-    /// Allocate and initialize a new database with pre-init options.
-    async fn new_database_with_opts(
-        &mut self,
-        opts: Vec<(options::OptionDatabase, OptionValue)>,
-    ) -> Result<Self::DatabaseType>;
-}
-
-/// A handle to an async ADBC database.
-///
-/// Databases hold state shared by multiple connections. This typically means
-/// configuration and caches. For in-memory databases, it provides a place to
-/// hold ownership of the in-memory database.
-///
-/// Databases must be kept alive as long as any connections exist.
-#[trait_variant::make(AsyncDatabase: Send)]
-pub trait LocalAsyncDatabase: LocalAsyncOptionable<Option = OptionDatabase> {
-    type ConnectionType: LocalAsyncConnection + Send;
-
-    /// Allocate and initialize a new connection without pre-init options.
-    async fn new_connection(&self) -> Result<Self::ConnectionType>;
-
-    /// Allocate and initialize a new connection with pre-init options.
-    async fn new_connection_with_opts(
-        &self,
-        opts: Vec<(options::OptionConnection, OptionValue)>,
-    ) -> Result<Self::ConnectionType>;
-}
-
-/// A handle to an async ADBC connection.
-///
-/// Connections provide methods for query execution, managing prepared
-/// statements, using transactions, and so on.
-///
-/// # Autocommit
-///
-/// Connections should start in autocommit mode. They can be moved out by
-/// setting [options::OptionConnection::AutoCommit] to "false". Turning off
-/// autocommit allows customizing the isolation level.
-#[trait_variant::make(AsyncConnection: Send)]
-pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection> {
-    type StatementType: LocalAsyncStatement;
-
-    /// Allocate and initialize a new statement.
-    async fn new_statement(&mut self) -> Result<Self::StatementType>;
-
-    /// Cancel the in-progress operation on a connection.
-    async fn cancel(&mut self) -> Result<()>;
-
-    /// Get metadata about the database/driver.
-    ///
-    /// # Arguments
-    ///
-    /// - `codes` - Requested metadata. If `None`, retrieve all available metadata.
-    ///
-    /// # Result
-    ///
-    /// The result is an Arrow dataset with the following schema:
-    ///
-    /// Field Name                  | Field Type
-    /// ----------------------------|------------------------
-    /// info_name                   | uint32 not null
-    /// info_value                  | INFO_SCHEMA
-    ///
-    /// INFO_SCHEMA is a dense union with members:
-    ///
-    /// Field Name (Type Code)      | Field Type
-    /// ----------------------------|------------------------
-    /// string_value (0)            | utf8
-    /// bool_value (1)              | bool
-    /// int64_value (2)             | int64
-    /// int32_bitmask (3)           | int32
-    /// string_list (4)             | list\<utf8\>
-    /// int32_to_int32_list_map (5) | map\<int32, list\<int32\>\>
-    async fn get_info(
-        &self,
-        codes: Option<HashSet<options::InfoCode>>,
-    ) -> Result<impl RecordBatchReader + Send>;
-
-    /// Get a hierarchical view of all catalogs, database schemas, tables, and
-    /// columns.
-    ///
-    /// # Arguments
-    ///
-    /// - `depth` - The level of nesting to query.
-    /// - `catalog` - Only show tables in the given catalog. If `None`,
-    ///   do not filter by catalog. If an empty string, only show tables
-    ///   without a catalog.  May be a search pattern.
-    /// - `db_schema` - Only show tables in the given database schema. If
-    ///   `None`, do not filter by database schema. If an empty string, only show
-    ///   tables without a database schema. May be a search pattern.
-    /// - `table_name` - Only show tables with the given name. If `None`, do not
-    ///   filter by name. May be a search pattern.
-    /// - `table_type` - Only show tables matching one of the given table
-    ///   types. If `None`, show tables of any type. Valid table types can be fetched
-    ///   from [AsyncConnection::get_table_types].
-    /// - `column_name` - Only show columns with the given name. If
-    ///   `None`, do not filter by name.  May be a search pattern..
-    ///
-    /// # Result
-    ///
-    /// The result is an Arrow dataset with the following schema:
-    ///
-    /// | Field Name               | Field Type               |
-    /// |--------------------------|--------------------------|
-    /// | catalog_name             | utf8                     |
-    /// | catalog_db_schemas       | list\<DB_SCHEMA_SCHEMA\> |
-    ///
-    /// DB_SCHEMA_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type              |
-    /// |--------------------------|-------------------------|
-    /// | db_schema_name           | utf8                    |
-    /// | db_schema_tables         | list\<TABLE_SCHEMA\>    |
-    ///
-    /// TABLE_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type                |
-    /// |--------------------------|---------------------------|
-    /// | table_name               | utf8 not null             |
-    /// | table_type               | utf8 not null             |
-    /// | table_columns            | list\<COLUMN_SCHEMA\>     |
-    /// | table_constraints        | list\<CONSTRAINT_SCHEMA\> |
-    ///
-    /// COLUMN_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type              | Comments |
-    /// |--------------------------|-------------------------|----------|
-    /// | column_name              | utf8 not null           |          |
-    /// | ordinal_position         | int32                   | (1)      |
-    /// | remarks                  | utf8                    | (2)      |
-    /// | xdbc_data_type           | int16                   | (3)      |
-    /// | xdbc_type_name           | utf8                    | (3)      |
-    /// | xdbc_column_size         | int32                   | (3)      |
-    /// | xdbc_decimal_digits      | int16                   | (3)      |
-    /// | xdbc_num_prec_radix      | int16                   | (3)      |
-    /// | xdbc_nullable            | int16                   | (3)      |
-    /// | xdbc_column_def          | utf8                    | (3)      |
-    /// | xdbc_sql_data_type       | int16                   | (3)      |
-    /// | xdbc_datetime_sub        | int16                   | (3)      |
-    /// | xdbc_char_octet_length   | int32                   | (3)      |
-    /// | xdbc_is_nullable         | utf8                    | (3)      |
-    /// | xdbc_scope_catalog       | utf8                    | (3)      |
-    /// | xdbc_scope_schema        | utf8                    | (3)      |
-    /// | xdbc_scope_table         | utf8                    | (3)      |
-    /// | xdbc_is_autoincrement    | bool                    | (3)      |
-    /// | xdbc_is_generatedcolumn  | bool                    | (3)      |
-    ///
-    /// 1. The column's ordinal position in the table (starting from 1).
-    /// 2. Database-specific description of the column.
-    /// 3. Optional value.  Should be null if not supported by the driver.
-    ///    `xdbc_` values are meant to provide JDBC/ODBC-compatible metadata
-    ///    in an agnostic manner.
-    ///
-    /// CONSTRAINT_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type              | Comments |
-    /// |--------------------------|-------------------------|----------|
-    /// | constraint_name          | utf8                    |          |
-    /// | constraint_type          | utf8 not null           | (1)      |
-    /// | constraint_column_names  | list\<utf8\> not null     | (2)      |
-    /// | constraint_column_usage  | list\<USAGE_SCHEMA\>      | (3)      |
-    ///
-    /// 1. One of `CHECK`, `FOREIGN KEY`, `PRIMARY KEY`, or `UNIQUE`.
-    /// 2. The columns on the current table that are constrained, in
-    ///    order.
-    /// 3. For `FOREIGN KEY` only, the referenced table and columns.
-    ///
-    /// USAGE_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type              |
-    /// |--------------------------|-------------------------|
-    /// | fk_catalog               | utf8                    |
-    /// | fk_db_schema             | utf8                    |
-    /// | fk_table                 | utf8 not null           |
-    /// | fk_column_name           | utf8 not null           |
-    ///
-    async fn get_objects(
-        &self,
-        depth: options::ObjectDepth,
-        catalog: Option<&str>,
-        db_schema: Option<&str>,
-        table_name: Option<&str>,
-        table_type: Option<Vec<&str>>,
-        column_name: Option<&str>,
-    ) -> Result<impl RecordBatchReader + Send>;
-
-    /// Get the Arrow schema of a table.
-    ///
-    /// # Arguments
-    ///
-    /// - `catalog` - The catalog (or `None` if not applicable).
-    /// - `db_schema` - The database schema (or `None` if not applicable).
-    /// - `table_name` - The table name.
-    async fn get_table_schema(
-        &self,
-        catalog: Option<&str>,
-        db_schema: Option<&str>,
-        table_name: &str,
-    ) -> Result<Schema>;
-
-    /// Get a list of table types in the database.
-    ///
-    /// # Result
-    ///
-    /// The result is an Arrow dataset with the following schema:
-    ///
-    /// Field Name     | Field Type
-    /// ---------------|--------------
-    /// table_type     | utf8 not null
-    async fn get_table_types(&self) -> Result<impl RecordBatchReader + Send>;
-
-    /// Get the names of statistics specific to this driver.
-    ///
-    /// # Result
-    ///
-    /// The result is an Arrow dataset with the following schema:
-    ///
-    /// Field Name     | Field Type
-    /// ---------------|----------------
-    /// statistic_name | utf8 not null
-    /// statistic_key  | int16 not null
-    ///
-    /// # Since
-    /// ADBC API revision 1.1.0
-    async fn get_statistic_names(&self) -> Result<impl RecordBatchReader + Send>;
-
-    /// Get statistics about the data distribution of table(s).
-    ///
-    /// # Arguments
-    ///
-    /// - `catalog` - The catalog (or `None` if not applicable). May be a search pattern.
-    /// - `db_schema` - The database schema (or `None` if not applicable). May be a search pattern
-    /// - `table_name` - The table name (or `None` if not applicable). May be a search pattern
-    /// - `approximate` - If false, request exact values of statistics, else
-    ///   allow for best-effort, approximate, or cached values. The database may
-    ///   return approximate values regardless, as indicated in the result.
-    ///   Requesting exact values may be expensive or unsupported.
-    ///
-    /// # Result
-    ///
-    /// The result is an Arrow dataset with the following schema:
-    ///
-    /// | Field Name               | Field Type                       |
-    /// |--------------------------|----------------------------------|
-    /// | catalog_name             | utf8                             |
-    /// | catalog_db_schemas       | list\<DB_SCHEMA_SCHEMA\> not null|
-    ///
-    /// DB_SCHEMA_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type                        |
-    /// |--------------------------|-----------------------------------|
-    /// | db_schema_name           | utf8                              |
-    /// | db_schema_statistics     | list\<STATISTICS_SCHEMA\> not null|
-    ///
-    /// STATISTICS_SCHEMA is a Struct with fields:
-    ///
-    /// | Field Name               | Field Type                       | Comments |
-    /// |--------------------------|----------------------------------| -------- |
-    /// | table_name               | utf8 not null                    |          |
-    /// | column_name              | utf8                             | (1)      |
-    /// | statistic_key            | int16 not null                   | (2)      |
-    /// | statistic_value          | VALUE_SCHEMA not null            |          |
-    /// | statistic_is_approximate | bool not null                    | (3)      |
-    ///
-    /// 1. If null, then the statistic applies to the entire table.
-    /// 2. A dictionary-encoded statistic name (although we do not use the Arrow
-    ///    dictionary type). Values in [0, 1024) are reserved for ADBC.  Other
-    ///    values are for implementation-specific statistics.  For the definitions
-    ///    of predefined statistic types, see [options::Statistics]. To get
-    ///    driver-specific statistic names, use [AsyncConnection::get_statistic_names].
-    /// 3. If true, then the value is approximate or best-effort.
-    ///
-    /// VALUE_SCHEMA is a dense union with members:
-    ///
-    /// | Field Name               | Field Type                       |
-    /// |--------------------------|----------------------------------|
-    /// | int64                    | int64                            |
-    /// | uint64                   | uint64                           |
-    /// | float64                  | float64                          |
-    /// | binary                   | binary                           |
-    ///
-    /// # Since
-    ///
-    /// ADBC API revision 1.1.0
-    async fn get_statistics(
-        &self,
-        catalog: Option<&str>,
-        db_schema: Option<&str>,
-        table_name: Option<&str>,
-        approximate: bool,
-    ) -> Result<impl RecordBatchReader + Send>;
-
-    /// Commit any pending transactions. Only used if autocommit is disabled.
-    ///
-    /// Behavior is undefined if this is mixed with SQL transaction statements.
-    async fn commit(&mut self) -> Result<()>;
-
-    /// Roll back any pending transactions. Only used if autocommit is disabled.
-    ///
-    /// Behavior is undefined if this is mixed with SQL transaction statements.
-    async fn rollback(&mut self) -> Result<()>;
-
-    /// Retrieve a given partition of data.
-    ///
-    /// A partition can be retrieved from [AsyncStatement::execute_partitions].
-    ///
-    /// # Arguments
-    ///
-    /// - `partition` - The partition descriptor.
-    async fn read_partition(
-        &self,
-        partition: &[u8],
-    ) -> Result<impl RecordBatchReader + Send + 'static>;
-}
-
-/// A handle to an async ADBC statement.
-///
-/// A statement is a container for all state needed to execute a database query,
-/// such as the query itself, parameters for prepared statements, driver
-/// parameters, etc.
-///
-/// Statements may represent queries or prepared statements.
-///
-/// Statements may be used multiple times and can be reconfigured
-/// (e.g. they can be reused to execute multiple different queries).
-/// However, executing a statement (and changing certain other state)
-/// will invalidate result sets obtained prior to that execution.
-///
-/// Multiple statements may be created from a single connection.
-/// However, the driver may block or error if they are used concurrently
-/// (whether from a single thread or multiple threads).
-#[trait_variant::make(AsyncStatement: Send)]
-pub trait LocalAsyncStatement: LocalAsyncOptionable<Option = OptionStatement> {
-    /// Bind Arrow data. This can be used for bulk inserts or prepared
-    /// statements.
-    async fn bind(&mut self, batch: RecordBatch) -> Result<()>;
-
-    /// Bind Arrow data. This can be used for bulk inserts or prepared
-    /// statements.
-    // TODO(alexandreyc): should we use a generic here instead of a trait object?
-    // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567750972
-    async fn bind_stream(&mut self, reader: Box<dyn RecordBatchReader + Send>) -> Result<()>;
-
-    /// Execute a statement and get the results.
-    ///
-    /// This invalidates any prior result sets.
-    // TODO(alexandreyc): is the Send bound absolutely necessary? same question
-    // for all methods that return an impl RecordBatchReader
-    // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567748242
-    async fn execute(&mut self) -> Result<impl RecordBatchReader + Send>;
-
-    /// Execute a statement that doesn’t have a result set and get the number
-    /// of affected rows.
-    ///
-    /// This invalidates any prior result sets.
-    ///
-    /// # Result
-    ///
-    /// Will return the number of rows affected. If the affected row count is
-    /// unknown or unsupported by the database, will return `None`.
-    async fn execute_update(&mut self) -> Result<Option<i64>>;
-
-    /// Get the schema of the result set of a query without executing it.
-    ///
-    /// This invalidates any prior result sets.
-    ///
-    /// Depending on the driver, this may require first executing
-    /// [AsyncStatement::prepare].
-    ///
-    /// # Since
-    ///
-    /// ADBC API revision 1.1.0
-    async fn execute_schema(&mut self) -> Result<Schema>;
-
-    /// Execute a statement and get the results as a partitioned result set.
-    async fn execute_partitions(&mut self) -> Result<PartitionedResult>;
-
-    /// Get the schema for bound parameters.
-    ///
-    /// This retrieves an Arrow schema describing the number, names, and
-    /// types of the parameters in a parameterized statement. The fields
-    /// of the schema should be in order of the ordinal position of the
-    /// parameters; named parameters should appear only once.
-    ///
-    /// If the parameter does not have a name, or the name cannot be
-    /// determined, the name of the corresponding field in the schema will
-    /// be an empty string. If the type cannot be determined, the type of
-    /// the corresponding field will be NA (NullType).
-    ///
-    /// This should be called after [AsyncStatement::prepare].
-    async fn get_parameter_schema(&self) -> Result<Schema>;
-
-    /// Turn this statement into a prepared statement to be executed multiple
-    /// times.
-    ///
-    /// This invalidates any prior result sets.
-    async fn prepare(&mut self) -> Result<()>;
-
-    /// Set the SQL query to execute.
-    ///
-    /// The query can then be executed with [AsyncStatement::execute]. For queries
-    /// expected to be executed repeatedly, call [AsyncStatement::prepare] first.
-    async fn set_sql_query(&mut self, query: &str) -> Result<()>;
-
-    /// Set the Substrait plan to execute.
-    ///
-    /// The query can then be executed with [AsyncStatement::execute]. For queries
-    /// expected to be executed repeatedly, call [AsyncStatement::prepare] first.
-    async fn set_substrait_plan(&mut self, plan: &[u8]) -> Result<()>;
-
-    /// Cancel execution of an in-progress query.
-    ///
-    /// This can be called during [AsyncStatement::execute] (or similar), or while
-    /// consuming a result set returned from such.
-    ///
-    /// # Since
-    ///
-    /// ADBC API revision 1.1.0
-    async fn cancel(&mut self) -> Result<()>;
-}
+pub use local::*;
+pub use send::*;
diff --git a/rust/core/src/non_blocking/local.rs b/rust/core/src/non_blocking/local.rs
new file mode 100644
index 0000000000..1788ea14bb
--- /dev/null
+++ b/rust/core/src/non_blocking/local.rs
@@ -0,0 +1,473 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use arrow_array::{RecordBatch, RecordBatchReader};
+use arrow_schema::Schema;
+
+use std::collections::HashSet;
+
+use crate::error::Result;
+use crate::options::*;
+
+/// Ability to configure an object by setting/getting options.
+#[allow(async_fn_in_trait)]
+pub trait LocalAsyncOptionable {
+    type Option: AsRef<str>;
+
+    /// Set a post-init option.
+    async fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()>;
+
+    /// Get a string option value by key.
+    async fn get_option_string(&self, key: Self::Option) -> Result<String>;
+
+    /// Get a bytes option value by key.
+    async fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>>;
+
+    /// Get an integer option value by key.
+    async fn get_option_int(&self, key: Self::Option) -> Result<i64>;
+
+    /// Get a float option value by key.
+    async fn get_option_double(&self, key: Self::Option) -> Result<f64>;
+}
+
+/// A handle to an async ADBC driver.
+#[allow(async_fn_in_trait)]
+pub trait LocalAsyncDriver {
+    type DatabaseType: LocalAsyncDatabase;
+
+    /// Allocate and initialize a new database without pre-init options.
+    async fn new_database(&mut self) -> Result<Self::DatabaseType>;
+
+    /// Allocate and initialize a new database with pre-init options.
+    async fn new_database_with_opts(
+        &mut self,
+        opts: Vec<(OptionDatabase, OptionValue)>,
+    ) -> Result<Self::DatabaseType>;
+}
+
+/// A handle to an async ADBC database.
+///
+/// Databases hold state shared by multiple connections. This typically means
+/// configuration and caches. For in-memory databases, it provides a place to
+/// hold ownership of the in-memory database.
+///
+/// Databases must be kept alive as long as any connections exist.
+#[allow(async_fn_in_trait)]
+pub trait LocalAsyncDatabase: LocalAsyncOptionable<Option = OptionDatabase> {
+    type ConnectionType: LocalAsyncConnection;
+
+    /// Allocate and initialize a new connection without pre-init options.
+    async fn new_connection(&self) -> Result<Self::ConnectionType>;
+
+    /// Allocate and initialize a new connection with pre-init options.
+    async fn new_connection_with_opts(
+        &self,
+        opts: Vec<(OptionConnection, OptionValue)>,
+    ) -> Result<Self::ConnectionType>;
+}
+
+/// A handle to an async ADBC connection.
+///
+/// Connections provide methods for query execution, managing prepared
+/// statements, using transactions, and so on.
+///
+/// # Autocommit
+///
+/// Connections should start in autocommit mode. They can be moved out by
+/// setting [options::OptionConnection::AutoCommit] to "false". Turning off
+/// autocommit allows customizing the isolation level.
+#[allow(async_fn_in_trait)]
+pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection> {
+    type StatementType: LocalAsyncStatement;
+
+    /// Allocate and initialize a new statement.
+    async fn new_statement(&mut self) -> Result<Self::StatementType>;
+
+    /// Cancel the in-progress operation on a connection.
+    async fn cancel(&mut self) -> Result<()>;
+
+    /// Get metadata about the database/driver.
+    ///
+    /// # Arguments
+    ///
+    /// - `codes` - Requested metadata. If `None`, retrieve all available metadata.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// Field Name                  | Field Type
+    /// ----------------------------|------------------------
+    /// info_name                   | uint32 not null
+    /// info_value                  | INFO_SCHEMA
+    ///
+    /// INFO_SCHEMA is a dense union with members:
+    ///
+    /// Field Name (Type Code)      | Field Type
+    /// ----------------------------|------------------------
+    /// string_value (0)            | utf8
+    /// bool_value (1)              | bool
+    /// int64_value (2)             | int64
+    /// int32_bitmask (3)           | int32
+    /// string_list (4)             | list\<utf8\>
+    /// int32_to_int32_list_map (5) | map\<int32, list\<int32\>\>
+    async fn get_info(
+        &self,
+        codes: Option<HashSet<InfoCode>>,
+    ) -> Result<impl RecordBatchReader + Send>;
+
+    /// Get a hierarchical view of all catalogs, database schemas, tables, and
+    /// columns.
+    ///
+    /// # Arguments
+    ///
+    /// - `depth` - The level of nesting to query.
+    /// - `catalog` - Only show tables in the given catalog. If `None`,
+    ///   do not filter by catalog. If an empty string, only show tables
+    ///   without a catalog.  May be a search pattern.
+    /// - `db_schema` - Only show tables in the given database schema. If
+    ///   `None`, do not filter by database schema. If an empty string, only show
+    ///   tables without a database schema. May be a search pattern.
+    /// - `table_name` - Only show tables with the given name. If `None`, do not
+    ///   filter by name. May be a search pattern.
+    /// - `table_type` - Only show tables matching one of the given table
+    ///   types. If `None`, show tables of any type. Valid table types can be fetched
+    ///   from [AsyncConnection::get_table_types].
+    /// - `column_name` - Only show columns with the given name. If
+    ///   `None`, do not filter by name.  May be a search pattern..
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// | Field Name               | Field Type               |
+    /// |--------------------------|--------------------------|
+    /// | catalog_name             | utf8                     |
+    /// | catalog_db_schemas       | list\<DB_SCHEMA_SCHEMA\> |
+    ///
+    /// DB_SCHEMA_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              |
+    /// |--------------------------|-------------------------|
+    /// | db_schema_name           | utf8                    |
+    /// | db_schema_tables         | list\<TABLE_SCHEMA\>    |
+    ///
+    /// TABLE_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type                |
+    /// |--------------------------|---------------------------|
+    /// | table_name               | utf8 not null             |
+    /// | table_type               | utf8 not null             |
+    /// | table_columns            | list\<COLUMN_SCHEMA\>     |
+    /// | table_constraints        | list\<CONSTRAINT_SCHEMA\> |
+    ///
+    /// COLUMN_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              | Comments |
+    /// |--------------------------|-------------------------|----------|
+    /// | column_name              | utf8 not null           |          |
+    /// | ordinal_position         | int32                   | (1)      |
+    /// | remarks                  | utf8                    | (2)      |
+    /// | xdbc_data_type           | int16                   | (3)      |
+    /// | xdbc_type_name           | utf8                    | (3)      |
+    /// | xdbc_column_size         | int32                   | (3)      |
+    /// | xdbc_decimal_digits      | int16                   | (3)      |
+    /// | xdbc_num_prec_radix      | int16                   | (3)      |
+    /// | xdbc_nullable            | int16                   | (3)      |
+    /// | xdbc_column_def          | utf8                    | (3)      |
+    /// | xdbc_sql_data_type       | int16                   | (3)      |
+    /// | xdbc_datetime_sub        | int16                   | (3)      |
+    /// | xdbc_char_octet_length   | int32                   | (3)      |
+    /// | xdbc_is_nullable         | utf8                    | (3)      |
+    /// | xdbc_scope_catalog       | utf8                    | (3)      |
+    /// | xdbc_scope_schema        | utf8                    | (3)      |
+    /// | xdbc_scope_table         | utf8                    | (3)      |
+    /// | xdbc_is_autoincrement    | bool                    | (3)      |
+    /// | xdbc_is_generatedcolumn  | bool                    | (3)      |
+    ///
+    /// 1. The column's ordinal position in the table (starting from 1).
+    /// 2. Database-specific description of the column.
+    /// 3. Optional value.  Should be null if not supported by the driver.
+    ///    `xdbc_` values are meant to provide JDBC/ODBC-compatible metadata
+    ///    in an agnostic manner.
+    ///
+    /// CONSTRAINT_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              | Comments |
+    /// |--------------------------|-------------------------|----------|
+    /// | constraint_name          | utf8                    |          |
+    /// | constraint_type          | utf8 not null           | (1)      |
+    /// | constraint_column_names  | list\<utf8\> not null     | (2)      |
+    /// | constraint_column_usage  | list\<USAGE_SCHEMA\>      | (3)      |
+    ///
+    /// 1. One of `CHECK`, `FOREIGN KEY`, `PRIMARY KEY`, or `UNIQUE`.
+    /// 2. The columns on the current table that are constrained, in
+    ///    order.
+    /// 3. For `FOREIGN KEY` only, the referenced table and columns.
+    ///
+    /// USAGE_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              |
+    /// |--------------------------|-------------------------|
+    /// | fk_catalog               | utf8                    |
+    /// | fk_db_schema             | utf8                    |
+    /// | fk_table                 | utf8 not null           |
+    /// | fk_column_name           | utf8 not null           |
+    async fn get_objects(
+        &self,
+        depth: ObjectDepth,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        table_type: Option<Vec<&str>>,
+        column_name: Option<&str>,
+    ) -> Result<impl RecordBatchReader + Send>;
+
+    /// Get the Arrow schema of a table.
+    ///
+    /// # Arguments
+    ///
+    /// - `catalog` - The catalog (or `None` if not applicable).
+    /// - `db_schema` - The database schema (or `None` if not applicable).
+    /// - `table_name` - The table name.
+    async fn get_table_schema(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: &str,
+    ) -> Result<Schema>;
+
+    /// Get a list of table types in the database.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// Field Name     | Field Type
+    /// ---------------|--------------
+    /// table_type     | utf8 not null
+    async fn get_table_types(&self) -> Result<impl RecordBatchReader + Send>;
+
+    /// Get the names of statistics specific to this driver.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// Field Name     | Field Type
+    /// ---------------|----------------
+    /// statistic_name | utf8 not null
+    /// statistic_key  | int16 not null
+    ///
+    /// # Since
+    /// ADBC API revision 1.1.0
+    async fn get_statistic_names(&self) -> Result<impl RecordBatchReader + Send>;
+
+    /// Get statistics about the data distribution of table(s).
+    ///
+    /// # Arguments
+    ///
+    /// - `catalog` - The catalog (or `None` if not applicable). May be a search pattern.
+    /// - `db_schema` - The database schema (or `None` if not applicable). May be a search pattern
+    /// - `table_name` - The table name (or `None` if not applicable). May be a search pattern
+    /// - `approximate` - If false, request exact values of statistics, else
+    ///   allow for best-effort, approximate, or cached values. The database may
+    ///   return approximate values regardless, as indicated in the result.
+    ///   Requesting exact values may be expensive or unsupported.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// | Field Name               | Field Type                       |
+    /// |--------------------------|----------------------------------|
+    /// | catalog_name             | utf8                             |
+    /// | catalog_db_schemas       | list\<DB_SCHEMA_SCHEMA\> not null|
+    ///
+    /// DB_SCHEMA_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type                        |
+    /// |--------------------------|-----------------------------------|
+    /// | db_schema_name           | utf8                              |
+    /// | db_schema_statistics     | list\<STATISTICS_SCHEMA\> not null|
+    ///
+    /// STATISTICS_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type                       | Comments |
+    /// |--------------------------|----------------------------------| -------- |
+    /// | table_name               | utf8 not null                    |          |
+    /// | column_name              | utf8                             | (1)      |
+    /// | statistic_key            | int16 not null                   | (2)      |
+    /// | statistic_value          | VALUE_SCHEMA not null            |          |
+    /// | statistic_is_approximate | bool not null                    | (3)      |
+    ///
+    /// 1. If null, then the statistic applies to the entire table.
+    /// 2. A dictionary-encoded statistic name (although we do not use the Arrow
+    ///    dictionary type). Values in [0, 1024) are reserved for ADBC.  Other
+    ///    values are for implementation-specific statistics.  For the definitions
+    ///    of predefined statistic types, see [options::Statistics]. To get
+    ///    driver-specific statistic names, use [AsyncConnection::get_statistic_names].
+    /// 3. If true, then the value is approximate or best-effort.
+    ///
+    /// VALUE_SCHEMA is a dense union with members:
+    ///
+    /// | Field Name               | Field Type                       |
+    /// |--------------------------|----------------------------------|
+    /// | int64                    | int64                            |
+    /// | uint64                   | uint64                           |
+    /// | float64                  | float64                          |
+    /// | binary                   | binary                           |
+    ///
+    /// # Since
+    ///
+    /// ADBC API revision 1.1.0
+    async fn get_statistics(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        approximate: bool,
+    ) -> Result<impl RecordBatchReader + Send>;
+
+    /// Commit any pending transactions. Only used if autocommit is disabled.
+    ///
+    /// Behavior is undefined if this is mixed with SQL transaction statements.
+    async fn commit(&mut self) -> Result<()>;
+
+    /// Roll back any pending transactions. Only used if autocommit is disabled.
+    ///
+    /// Behavior is undefined if this is mixed with SQL transaction statements.
+    async fn rollback(&mut self) -> Result<()>;
+
+    /// Retrieve a given partition of data.
+    ///
+    /// A partition can be retrieved from [AsyncStatement::execute_partitions].
+    ///
+    /// # Arguments
+    ///
+    /// - `partition` - The partition descriptor.
+    async fn read_partition(
+        &self,
+        partition: &[u8],
+    ) -> Result<impl RecordBatchReader + Send + 'static>;
+}
+
+/// A handle to an async ADBC statement.
+///
+/// A statement is a container for all state needed to execute a database query,
+/// such as the query itself, parameters for prepared statements, driver
+/// parameters, etc.
+///
+/// Statements may represent queries or prepared statements.
+///
+/// Statements may be used multiple times and can be reconfigured
+/// (e.g. they can be reused to execute multiple different queries).
+/// However, executing a statement (and changing certain other state)
+/// will invalidate result sets obtained prior to that execution.
+///
+/// Multiple statements may be created from a single connection.
+/// However, the driver may block or error if they are used concurrently
+/// (whether from a single thread or multiple threads).
+#[allow(async_fn_in_trait)]
+pub trait LocalAsyncStatement: LocalAsyncOptionable<Option = OptionStatement> {
+    /// Bind Arrow data. This can be used for bulk inserts or prepared
+    /// statements.
+    async fn bind(&mut self, batch: RecordBatch) -> Result<()>;
+
+    /// Bind Arrow data. This can be used for bulk inserts or prepared
+    /// statements.
+    // TODO(alexandreyc): should we use a generic here instead of a trait object?
+    // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567750972
+    async fn bind_stream(&mut self, reader: Box<dyn RecordBatchReader + Send>) -> Result<()>;
+
+    /// Execute a statement and get the results.
+    ///
+    /// This invalidates any prior result sets.
+    // TODO(alexandreyc): is the Send bound absolutely necessary? same question
+    // for all methods that return an impl RecordBatchReader
+    // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567748242
+    async fn execute(&mut self) -> Result<impl RecordBatchReader + Send>;
+
+    /// Execute a statement that doesn’t have a result set and get the number
+    /// of affected rows.
+    ///
+    /// This invalidates any prior result sets.
+    ///
+    /// # Result
+    ///
+    /// Will return the number of rows affected. If the affected row count is
+    /// unknown or unsupported by the database, will return `None`.
+    async fn execute_update(&mut self) -> Result<Option<i64>>;
+
+    /// Get the schema of the result set of a query without executing it.
+    ///
+    /// This invalidates any prior result sets.
+    ///
+    /// Depending on the driver, this may require first executing
+    /// [AsyncStatement::prepare].
+    ///
+    /// # Since
+    ///
+    /// ADBC API revision 1.1.0
+    async fn execute_schema(&mut self) -> Result<Schema>;
+
+    /// Execute a statement and get the results as a partitioned result set.
+    async fn execute_partitions(&mut self) -> Result<crate::PartitionedResult>;
+
+    /// Get the schema for bound parameters.
+    ///
+    /// This retrieves an Arrow schema describing the number, names, and
+    /// types of the parameters in a parameterized statement. The fields
+    /// of the schema should be in order of the ordinal position of the
+    /// parameters; named parameters should appear only once.
+    ///
+    /// If the parameter does not have a name, or the name cannot be
+    /// determined, the name of the corresponding field in the schema will
+    /// be an empty string. If the type cannot be determined, the type of
+    /// the corresponding field will be NA (NullType).
+    ///
+    /// This should be called after [AsyncStatement::prepare].
+    async fn get_parameter_schema(&self) -> Result<Schema>;
+
+    /// Turn this statement into a prepared statement to be executed multiple
+    /// times.
+    ///
+    /// This invalidates any prior result sets.
+    async fn prepare(&mut self) -> Result<()>;
+
+    /// Set the SQL query to execute.
+    ///
+    /// The query can then be executed with [AsyncStatement::execute]. For queries
+    /// expected to be executed repeatedly, call [AsyncStatement::prepare] first.
+    async fn set_sql_query(&mut self, query: &str) -> Result<()>;
+
+    /// Set the Substrait plan to execute.
+    ///
+    /// The query can then be executed with [AsyncStatement::execute]. For queries
+    /// expected to be executed repeatedly, call [AsyncStatement::prepare] first.
+    async fn set_substrait_plan(&mut self, plan: &[u8]) -> Result<()>;
+
+    /// Cancel execution of an in-progress query.
+    ///
+    /// This can be called during [AsyncStatement::execute] (or similar), or while
+    /// consuming a result set returned from such.
+    ///
+    /// # Since
+    ///
+    /// ADBC API revision 1.1.0
+    async fn cancel(&mut self) -> Result<()>;
+}
diff --git a/rust/core/src/non_blocking/send.rs b/rust/core/src/non_blocking/send.rs
new file mode 100644
index 0000000000..0a8e1d4ce6
--- /dev/null
+++ b/rust/core/src/non_blocking/send.rs
@@ -0,0 +1,675 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use arrow_array::{RecordBatch, RecordBatchReader};
+use arrow_schema::Schema;
+
+use std::collections::HashSet;
+
+use crate::error::Result;
+use crate::options::*;
+
+/// Ability to configure an object by setting/getting options.
+pub trait AsyncOptionable: Send {
+    type Option: AsRef<str> + Send;
+
+    /// Set a post-init option.
+    fn set_option(
+        &mut self,
+        key: Self::Option,
+        value: OptionValue,
+    ) -> impl core::future::Future<Output = Result<()>> + Send;
+
+    /// Get a string option value by key.
+    fn get_option_string(
+        &self,
+        key: Self::Option,
+    ) -> impl ::core::future::Future<Output = Result<String>> + Send;
+
+    /// Get a bytes option value by key.
+    fn get_option_bytes(
+        &self,
+        key: Self::Option,
+    ) -> impl ::core::future::Future<Output = Result<Vec<u8>>> + Send;
+
+    /// Get an integer option value by key.
+    fn get_option_int(
+        &self,
+        key: Self::Option,
+    ) -> impl ::core::future::Future<Output = Result<i64>> + Send;
+
+    /// Get a float option value by key.
+    fn get_option_double(
+        &self,
+        key: Self::Option,
+    ) -> impl ::core::future::Future<Output = Result<f64>> + Send;
+}
+
+impl<T: AsyncOptionable> super::LocalAsyncOptionable for T {
+    type Option = <Self as AsyncOptionable>::Option;
+
+    async fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()> {
+        <Self as AsyncOptionable>::set_option(self, key, value).await
+    }
+
+    async fn get_option_string(&self, key: Self::Option) -> Result<String> {
+        <Self as AsyncOptionable>::get_option_string(self, key).await
+    }
+
+    async fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>> {
+        <Self as AsyncOptionable>::get_option_bytes(self, key).await
+    }
+
+    async fn get_option_int(&self, key: Self::Option) -> Result<i64> {
+        <Self as AsyncOptionable>::get_option_int(self, key).await
+    }
+
+    async fn get_option_double(&self, key: Self::Option) -> Result<f64> {
+        <Self as AsyncOptionable>::get_option_double(self, key).await
+    }
+}
+
+/// A handle to an async ADBC driver
+pub trait AsyncDriver: Send {
+    type DatabaseType: AsyncDatabase;
+
+    /// Allocate and initialize a new database without pre-init options.
+    fn new_database(
+        &mut self,
+    ) -> impl core::future::Future<Output = Result<Self::DatabaseType>> + Send;
+
+    /// Allocate and initialize a new database with pre-init options.
+    fn new_database_with_opts(
+        &mut self,
+        opts: Vec<(OptionDatabase, OptionValue)>,
+    ) -> impl core::future::Future<Output = Result<Self::DatabaseType>> + Send;
+}
+
+impl<T: AsyncDriver> super::LocalAsyncDriver for T {
+    type DatabaseType = <Self as AsyncDriver>::DatabaseType;
+
+    async fn new_database(&mut self) -> Result<Self::DatabaseType> {
+        <Self as AsyncDriver>::new_database(self).await
+    }
+
+    async fn new_database_with_opts(
+        &mut self,
+        opts: Vec<(OptionDatabase, OptionValue)>,
+    ) -> Result<Self::DatabaseType> {
+        <Self as AsyncDriver>::new_database_with_opts(self, opts).await
+    }
+}
+
+/// A handle to an async ADBC database.
+///
+/// Databases hold state shared by multiple connections. This typically means
+/// configuration and caches. For in-memory databases, it provides a place to
+/// hold ownership of the in-memory database.
+///
+/// Databases must be kept alive as long as any connections exist.
+pub trait AsyncDatabase: AsyncOptionable<Option = OptionDatabase> + Send {
+    type ConnectionType: AsyncConnection;
+
+    /// Allocate and initialize a new connection without pre-init options.
+    fn new_connection(
+        &self,
+    ) -> impl core::future::Future<Output = Result<Self::ConnectionType>> + Send;
+
+    /// Allocate and initialize a new connection with pre-init options.
+    fn new_connection_with_opts(
+        &self,
+        opts: Vec<(OptionConnection, OptionValue)>,
+    ) -> impl core::future::Future<Output = Result<Self::ConnectionType>> + Send;
+}
+
+impl<T: AsyncDatabase> super::LocalAsyncDatabase for T {
+    type ConnectionType = <Self as AsyncDatabase>::ConnectionType;
+
+    async fn new_connection(&self) -> Result<Self::ConnectionType> {
+        <Self as AsyncDatabase>::new_connection(self).await
+    }
+
+    async fn new_connection_with_opts(
+        &self,
+        opts: Vec<(OptionConnection, OptionValue)>,
+    ) -> Result<Self::ConnectionType> {
+        <Self as AsyncDatabase>::new_connection_with_opts(self, opts).await
+    }
+}
+
+/// A handle to an async ADBC connection.
+///
+/// Connections provide methods for query execution, managing prepared
+/// statements, using transactions, and so on.
+///
+/// # Autocommit
+///
+/// Connections should start in autocommit mode. They can be moved out by
+/// setting [options::OptionConnection::AutoCommit] to "false". Turning off
+/// autocommit allows customizing the isolation level.
+pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
+    type StatementType: AsyncStatement;
+
+    /// Allocate and initialize a new statement.
+    fn new_statement(
+        &mut self,
+    ) -> impl core::future::Future<Output = Result<Self::StatementType>> + Send;
+
+    /// Cancel the in-progress operation on a connection.
+    fn cancel(&mut self) -> impl core::future::Future<Output = Result<()>> + Send;
+
+    /// Get metadata about the database/driver.
+    ///
+    /// # Arguments
+    ///
+    /// - `codes` - Requested metadata. If `None`, retrieve all available metadata.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// Field Name                  | Field Type
+    /// ----------------------------|------------------------
+    /// info_name                   | uint32 not null
+    /// info_value                  | INFO_SCHEMA
+    ///
+    /// INFO_SCHEMA is a dense union with members:
+    ///
+    /// Field Name (Type Code)      | Field Type
+    /// ----------------------------|------------------------
+    /// string_value (0)            | utf8
+    /// bool_value (1)              | bool
+    /// int64_value (2)             | int64
+    /// int32_bitmask (3)           | int32
+    /// string_list (4)             | list\<utf8\>
+    /// int32_to_int32_list_map (5) | map\<int32, list\<int32\>\>
+    fn get_info(
+        &self,
+        codes: Option<HashSet<InfoCode>>,
+    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+
+    /// Get a hierarchical view of all catalogs, database schemas, tables, and
+    /// columns.
+    ///
+    /// # Arguments
+    ///
+    /// - `depth` - The level of nesting to query.
+    /// - `catalog` - Only show tables in the given catalog. If `None`,
+    ///   do not filter by catalog. If an empty string, only show tables
+    ///   without a catalog.  May be a search pattern.
+    /// - `db_schema` - Only show tables in the given database schema. If
+    ///   `None`, do not filter by database schema. If an empty string, only show
+    ///   tables without a database schema. May be a search pattern.
+    /// - `table_name` - Only show tables with the given name. If `None`, do not
+    ///   filter by name. May be a search pattern.
+    /// - `table_type` - Only show tables matching one of the given table
+    ///   types. If `None`, show tables of any type. Valid table types can be fetched
+    ///   from [AsyncConnection::get_table_types].
+    /// - `column_name` - Only show columns with the given name. If
+    ///   `None`, do not filter by name.  May be a search pattern..
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// | Field Name               | Field Type               |
+    /// |--------------------------|--------------------------|
+    /// | catalog_name             | utf8                     |
+    /// | catalog_db_schemas       | list\<DB_SCHEMA_SCHEMA\> |
+    ///
+    /// DB_SCHEMA_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              |
+    /// |--------------------------|-------------------------|
+    /// | db_schema_name           | utf8                    |
+    /// | db_schema_tables         | list\<TABLE_SCHEMA\>    |
+    ///
+    /// TABLE_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type                |
+    /// |--------------------------|---------------------------|
+    /// | table_name               | utf8 not null             |
+    /// | table_type               | utf8 not null             |
+    /// | table_columns            | list\<COLUMN_SCHEMA\>     |
+    /// | table_constraints        | list\<CONSTRAINT_SCHEMA\> |
+    ///
+    /// COLUMN_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              | Comments |
+    /// |--------------------------|-------------------------|----------|
+    /// | column_name              | utf8 not null           |          |
+    /// | ordinal_position         | int32                   | (1)      |
+    /// | remarks                  | utf8                    | (2)      |
+    /// | xdbc_data_type           | int16                   | (3)      |
+    /// | xdbc_type_name           | utf8                    | (3)      |
+    /// | xdbc_column_size         | int32                   | (3)      |
+    /// | xdbc_decimal_digits      | int16                   | (3)      |
+    /// | xdbc_num_prec_radix      | int16                   | (3)      |
+    /// | xdbc_nullable            | int16                   | (3)      |
+    /// | xdbc_column_def          | utf8                    | (3)      |
+    /// | xdbc_sql_data_type       | int16                   | (3)      |
+    /// | xdbc_datetime_sub        | int16                   | (3)      |
+    /// | xdbc_char_octet_length   | int32                   | (3)      |
+    /// | xdbc_is_nullable         | utf8                    | (3)      |
+    /// | xdbc_scope_catalog       | utf8                    | (3)      |
+    /// | xdbc_scope_schema        | utf8                    | (3)      |
+    /// | xdbc_scope_table         | utf8                    | (3)      |
+    /// | xdbc_is_autoincrement    | bool                    | (3)      |
+    /// | xdbc_is_generatedcolumn  | bool                    | (3)      |
+    ///
+    /// 1. The column's ordinal position in the table (starting from 1).
+    /// 2. Database-specific description of the column.
+    /// 3. Optional value.  Should be null if not supported by the driver.
+    ///    `xdbc_` values are meant to provide JDBC/ODBC-compatible metadata
+    ///    in an agnostic manner.
+    ///
+    /// CONSTRAINT_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              | Comments |
+    /// |--------------------------|-------------------------|----------|
+    /// | constraint_name          | utf8                    |          |
+    /// | constraint_type          | utf8 not null           | (1)      |
+    /// | constraint_column_names  | list\<utf8\> not null     | (2)      |
+    /// | constraint_column_usage  | list\<USAGE_SCHEMA\>      | (3)      |
+    ///
+    /// 1. One of `CHECK`, `FOREIGN KEY`, `PRIMARY KEY`, or `UNIQUE`.
+    /// 2. The columns on the current table that are constrained, in
+    ///    order.
+    /// 3. For `FOREIGN KEY` only, the referenced table and columns.
+    ///
+    /// USAGE_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type              |
+    /// |--------------------------|-------------------------|
+    /// | fk_catalog               | utf8                    |
+    /// | fk_db_schema             | utf8                    |
+    /// | fk_table                 | utf8 not null           |
+    /// | fk_column_name           | utf8 not null           |
+    fn get_objects(
+        &self,
+        depth: ObjectDepth,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        table_type: Option<Vec<&str>>,
+        column_name: Option<&str>,
+    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+
+    /// Get the Arrow schema of a table.
+    ///
+    /// # Arguments
+    ///
+    /// - `catalog` - The catalog (or `None` if not applicable).
+    /// - `db_schema` - The database schema (or `None` if not applicable).
+    /// - `table_name` - The table name.
+    fn get_table_schema(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: &str,
+    ) -> impl core::future::Future<Output = Result<Schema>> + Send;
+
+    /// Get a list of table types in the database.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// Field Name     | Field Type
+    /// ---------------|--------------
+    /// table_type     | utf8 not null
+    fn get_table_types(
+        &self,
+    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+
+    /// Get the names of statistics specific to this driver.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// Field Name     | Field Type
+    /// ---------------|----------------
+    /// statistic_name | utf8 not null
+    /// statistic_key  | int16 not null
+    ///
+    /// # Since
+    /// ADBC API revision 1.1.0
+    fn get_statistic_names(
+        &self,
+    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+
+    /// Get statistics about the data distribution of table(s).
+    ///
+    /// # Arguments
+    ///
+    /// - `catalog` - The catalog (or `None` if not applicable). May be a search pattern.
+    /// - `db_schema` - The database schema (or `None` if not applicable). May be a search pattern
+    /// - `table_name` - The table name (or `None` if not applicable). May be a search pattern
+    /// - `approximate` - If false, request exact values of statistics, else
+    ///   allow for best-effort, approximate, or cached values. The database may
+    ///   return approximate values regardless, as indicated in the result.
+    ///   Requesting exact values may be expensive or unsupported.
+    ///
+    /// # Result
+    ///
+    /// The result is an Arrow dataset with the following schema:
+    ///
+    /// | Field Name               | Field Type                       |
+    /// |--------------------------|----------------------------------|
+    /// | catalog_name             | utf8                             |
+    /// | catalog_db_schemas       | list\<DB_SCHEMA_SCHEMA\> not null|
+    ///
+    /// DB_SCHEMA_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type                        |
+    /// |--------------------------|-----------------------------------|
+    /// | db_schema_name           | utf8                              |
+    /// | db_schema_statistics     | list\<STATISTICS_SCHEMA\> not null|
+    ///
+    /// STATISTICS_SCHEMA is a Struct with fields:
+    ///
+    /// | Field Name               | Field Type                       | Comments |
+    /// |--------------------------|----------------------------------| -------- |
+    /// | table_name               | utf8 not null                    |          |
+    /// | column_name              | utf8                             | (1)      |
+    /// | statistic_key            | int16 not null                   | (2)      |
+    /// | statistic_value          | VALUE_SCHEMA not null            |          |
+    /// | statistic_is_approximate | bool not null                    | (3)      |
+    ///
+    /// 1. If null, then the statistic applies to the entire table.
+    /// 2. A dictionary-encoded statistic name (although we do not use the Arrow
+    ///    dictionary type). Values in [0, 1024) are reserved for ADBC.  Other
+    ///    values are for implementation-specific statistics.  For the definitions
+    ///    of predefined statistic types, see [options::Statistics]. To get
+    ///    driver-specific statistic names, use [AsyncConnection::get_statistic_names].
+    /// 3. If true, then the value is approximate or best-effort.
+    ///
+    /// VALUE_SCHEMA is a dense union with members:
+    ///
+    /// | Field Name               | Field Type                       |
+    /// |--------------------------|----------------------------------|
+    /// | int64                    | int64                            |
+    /// | uint64                   | uint64                           |
+    /// | float64                  | float64                          |
+    /// | binary                   | binary                           |
+    ///
+    /// # Since
+    ///
+    /// ADBC API revision 1.1.0
+    fn get_statistics(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        approximate: bool,
+    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+
+    /// Commit any pending transactions. Only used if autocommit is disabled.
+    ///
+    /// Behavior is undefined if this is mixed with SQL transaction statements.
+    fn commit(&mut self) -> impl core::future::Future<Output = Result<()>> + Send;
+
+    /// Roll back any pending transactions. Only used if autocommit is disabled.
+    ///
+    /// Behavior is undefined if this is mixed with SQL transaction statements.
+    fn rollback(&mut self) -> impl core::future::Future<Output = Result<()>> + Send;
+
+    /// Retrieve a given partition of data.
+    ///
+    /// A partition can be retrieved from [AsyncStatement::execute_partitions].
+    ///
+    /// # Arguments
+    ///
+    /// - `partition` - The partition descriptor.
+    fn read_partition(
+        &self,
+        partition: &[u8],
+    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send + 'static>> + Send;
+}
+
+impl<T: AsyncConnection> super::LocalAsyncConnection for T {
+    type StatementType = <Self as AsyncConnection>::StatementType;
+
+    async fn new_statement(&mut self) -> Result<Self::StatementType> {
+        <Self as AsyncConnection>::new_statement(self).await
+    }
+
+    async fn cancel(&mut self) -> Result<()> {
+        <Self as AsyncConnection>::cancel(self).await
+    }
+
+    async fn get_info(
+        &self,
+        codes: Option<HashSet<InfoCode>>,
+    ) -> Result<impl RecordBatchReader + Send> {
+        <Self as AsyncConnection>::get_info(self, codes).await
+    }
+
+    async fn get_objects(
+        &self,
+        depth: ObjectDepth,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        table_type: Option<Vec<&str>>,
+        column_name: Option<&str>,
+    ) -> Result<impl RecordBatchReader + Send> {
+        <Self as AsyncConnection>::get_objects(
+            self,
+            depth,
+            catalog,
+            db_schema,
+            table_name,
+            table_type,
+            column_name,
+        )
+        .await
+    }
+
+    async fn get_table_schema(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: &str,
+    ) -> Result<Schema> {
+        <Self as AsyncConnection>::get_table_schema(self, catalog, db_schema, table_name).await
+    }
+
+    async fn get_table_types(&self) -> Result<impl RecordBatchReader + Send> {
+        <Self as AsyncConnection>::get_table_types(self).await
+    }
+
+    async fn get_statistic_names(&self) -> Result<impl RecordBatchReader + Send> {
+        <Self as AsyncConnection>::get_statistic_names(self).await
+    }
+
+    async fn get_statistics(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        approximate: bool,
+    ) -> Result<impl RecordBatchReader + Send> {
+        <Self as AsyncConnection>::get_statistics(self, catalog, db_schema, table_name, approximate)
+            .await
+    }
+
+    async fn commit(&mut self) -> Result<()> {
+        <Self as AsyncConnection>::commit(self).await
+    }
+
+    async fn rollback(&mut self) -> Result<()> {
+        <Self as AsyncConnection>::rollback(self).await
+    }
+
+    async fn read_partition(
+        &self,
+        partition: &[u8],
+    ) -> Result<impl RecordBatchReader + Send + 'static> {
+        <Self as AsyncConnection>::read_partition(self, partition).await
+    }
+}
+
+pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> + Send {
+    /// Bind Arrow data. This can be used for bulk inserts or prepared
+    /// statements.
+    fn bind(&mut self, batch: RecordBatch)
+        -> impl core::future::Future<Output = Result<()>> + Send;
+
+    /// Bind Arrow data. This can be used for bulk inserts or prepared
+    /// statements.
+    // TODO(alexandreyc): should we use a generic here instead of a trait object?
+    // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567750972
+    fn bind_stream(
+        &mut self,
+        reader: Box<dyn RecordBatchReader + Send>,
+    ) -> impl core::future::Future<Output = Result<()>> + Send;
+
+    /// Execute a statement and get the results.
+    ///
+    /// This invalidates any prior result sets.
+    // TODO(alexandreyc): is the Send bound absolutely necessary? same question
+    // for all methods that return an impl RecordBatchReader
+    // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567748242
+    fn execute(
+        &mut self,
+    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+
+    /// Execute a statement that doesn’t have a result set and get the number
+    /// of affected rows.
+    ///
+    /// This invalidates any prior result sets.
+    ///
+    /// # Result
+    ///
+    /// Will return the number of rows affected. If the affected row count is
+    /// unknown or unsupported by the database, will return `None`.
+    fn execute_update(&mut self) -> impl core::future::Future<Output = Result<Option<i64>>> + Send;
+
+    /// Get the schema of the result set of a query without executing it.
+    ///
+    /// This invalidates any prior result sets.
+    ///
+    /// Depending on the driver, this may require first executing
+    /// [AsyncStatement::prepare].
+    ///
+    /// # Since
+    ///
+    /// ADBC API revision 1.1.0
+    fn execute_schema(&mut self) -> impl core::future::Future<Output = Result<Schema>> + Send;
+
+    /// Execute a statement and get the results as a partitioned result set.
+    fn execute_partitions(
+        &mut self,
+    ) -> impl ::core::future::Future<Output = Result<crate::PartitionedResult>> + Send;
+
+    /// Get the schema for bound parameters.
+    ///
+    /// This retrieves an Arrow schema describing the number, names, and
+    /// types of the parameters in a parameterized statement. The fields
+    /// of the schema should be in order of the ordinal position of the
+    /// parameters; named parameters should appear only once.
+    ///
+    /// If the parameter does not have a name, or the name cannot be
+    /// determined, the name of the corresponding field in the schema will
+    /// be an empty string. If the type cannot be determined, the type of
+    /// the corresponding field will be NA (NullType).
+    ///
+    /// This should be called after [AsyncStatement::prepare].
+    fn get_parameter_schema(&self) -> impl core::future::Future<Output = Result<Schema>> + Send;
+
+    /// Turn this statement into a prepared statement to be executed multiple
+    /// times.
+    ///
+    /// This invalidates any prior result sets.
+    fn prepare(&mut self) -> impl core::future::Future<Output = Result<()>> + Send;
+
+    /// Set the SQL query to execute.
+    ///
+    /// The query can then be executed with [AsyncStatement::execute]. For queries
+    /// expected to be executed repeatedly, call [AsyncStatement::prepare] first.
+    fn set_sql_query(
+        &mut self,
+        query: &str,
+    ) -> impl core::future::Future<Output = Result<()>> + Send;
+
+    /// Set the Substrait plan to execute.
+    ///
+    /// The query can then be executed with [AsyncStatement::execute]. For queries
+    /// expected to be executed repeatedly, call [AsyncStatement::prepare] first.
+    fn set_substrait_plan(
+        &mut self,
+        plan: &[u8],
+    ) -> impl core::future::Future<Output = Result<()>> + Send;
+
+    /// Cancel execution of an in-progress query.
+    ///
+    /// This can be called during [AsyncStatement::execute] (or similar), or while
+    /// consuming a result set returned from such.
+    ///
+    /// # Since
+    ///
+    /// ADBC API revision 1.1.0
+    fn cancel(&mut self) -> impl core::future::Future<Output = Result<()>> + Send;
+}
+
+impl<T: AsyncStatement> super::LocalAsyncStatement for T {
+    async fn bind(&mut self, batch: RecordBatch) -> Result<()> {
+        <Self as AsyncStatement>::bind(self, batch).await
+    }
+
+    async fn bind_stream(&mut self, reader: Box<dyn RecordBatchReader + Send>) -> Result<()> {
+        <Self as AsyncStatement>::bind_stream(self, reader).await
+    }
+
+    async fn execute(&mut self) -> Result<impl RecordBatchReader + Send> {
+        <Self as AsyncStatement>::execute(self).await
+    }
+
+    async fn execute_update(&mut self) -> Result<Option<i64>> {
+        <Self as AsyncStatement>::execute_update(self).await
+    }
+
+    async fn execute_schema(&mut self) -> Result<Schema> {
+        <Self as AsyncStatement>::execute_schema(self).await
+    }
+
+    async fn execute_partitions(&mut self) -> Result<crate::PartitionedResult> {
+        <Self as AsyncStatement>::execute_partitions(self).await
+    }
+
+    async fn get_parameter_schema(&self) -> Result<Schema> {
+        <Self as AsyncStatement>::get_parameter_schema(self).await
+    }
+
+    async fn prepare(&mut self) -> Result<()> {
+        <Self as AsyncStatement>::prepare(self).await
+    }
+
+    async fn set_sql_query(&mut self, query: &str) -> Result<()> {
+        <Self as AsyncStatement>::set_sql_query(self, query).await
+    }
+
+    async fn set_substrait_plan(&mut self, plan: &[u8]) -> Result<()> {
+        <Self as AsyncStatement>::set_substrait_plan(self, plan).await
+    }
+
+    async fn cancel(&mut self) -> Result<()> {
+        <Self as AsyncStatement>::cancel(self).await
+    }
+}
diff --git a/rust/driver/datafusion/src/lib.rs b/rust/driver/datafusion/src/lib.rs
index 6fac98e860..f25633f1e6 100644
--- a/rust/driver/datafusion/src/lib.rs
+++ b/rust/driver/datafusion/src/lib.rs
@@ -17,10 +17,8 @@
 #![allow(refining_impl_trait)]
 
 use adbc_core::executor::AsyncExecutor;
-use adbc_core::non_blocking::{
-    AsyncConnection, AsyncDatabase, AsyncDriver, AsyncStatement, LocalAsyncOptionable,
-};
-use adbc_core::{constants, options};
+use adbc_core::non_blocking::{AsyncConnection, AsyncDatabase, AsyncDriver, AsyncStatement};
+use adbc_core::{constants, options, AsyncOptionable};
 use datafusion::dataframe::DataFrameWriteOptions;
 use datafusion::datasource::TableType;
 use datafusion::prelude::*;
@@ -169,7 +167,7 @@ impl AsyncDriver for DataFusionDriver {
 
 pub struct DataFusionDatabase {}
 
-impl LocalAsyncOptionable for DataFusionDatabase {
+impl AsyncOptionable for DataFusionDatabase {
     type Option = OptionDatabase;
 
     async fn set_option(
@@ -241,7 +239,7 @@ pub struct DataFusionConnection {
     ctx: Arc<SessionContext>,
 }
 
-impl LocalAsyncOptionable for DataFusionConnection {
+impl AsyncOptionable for DataFusionConnection {
     type Option = OptionConnection;
 
     async fn set_option(
@@ -789,7 +787,7 @@ pub struct DataFusionStatement {
     ingest_target_table: Option<String>,
 }
 
-impl LocalAsyncOptionable for DataFusionStatement {
+impl AsyncOptionable for DataFusionStatement {
     type Option = OptionStatement;
 
     async fn set_option(

From 438b1c0205b8e8e63fc80bef2443c39abd6a1193 Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Wed, 26 Nov 2025 11:50:39 +0300
Subject: [PATCH 08/14] changes: renamed blocking into sync

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/core/src/lib.rs                               | 2 +-
 rust/core/src/{blocking.rs => sync.rs}             | 0
 rust/driver/datafusion/README.md                   | 2 +-
 rust/driver/datafusion/src/lib.rs                  | 2 +-
 rust/driver/dummy/src/lib.rs                       | 5 +++--
 rust/driver/dummy/tests/driver_exporter_dummy.rs   | 2 +-
 rust/driver/snowflake/README.md                    | 2 +-
 rust/driver/snowflake/src/connection.rs            | 4 ++--
 rust/driver/snowflake/src/connection/builder.rs    | 2 +-
 rust/driver/snowflake/src/database.rs              | 4 ++--
 rust/driver/snowflake/src/database/builder.rs      | 2 +-
 rust/driver/snowflake/src/driver.rs                | 2 +-
 rust/driver/snowflake/src/statement.rs             | 4 ++--
 rust/driver/snowflake/tests/driver.rs              | 2 +-
 rust/driver_manager/src/lib.rs                     | 4 ++--
 rust/driver_manager/tests/common/mod.rs            | 2 +-
 rust/driver_manager/tests/driver_manager_sqlite.rs | 2 +-
 rust/ffi/src/driver_exporter.rs                    | 2 +-
 rust/ffi/src/lib.rs                                | 2 +-
 19 files changed, 24 insertions(+), 23 deletions(-)
 rename rust/core/src/{blocking.rs => sync.rs} (100%)

diff --git a/rust/core/src/lib.rs b/rust/core/src/lib.rs
index 8e1a06a03e..7f2ee79e88 100644
--- a/rust/core/src/lib.rs
+++ b/rust/core/src/lib.rs
@@ -39,13 +39,13 @@
 //! For drivers implemented in Rust, using these will be more efficient and
 //! safe, since it avoids the overhead of going through C FFI.
 
-pub mod blocking;
 pub mod constants;
 pub mod error;
 pub mod executor;
 pub mod non_blocking;
 pub mod options;
 pub mod schemas;
+pub mod sync;
 
 pub use non_blocking::*;
 
diff --git a/rust/core/src/blocking.rs b/rust/core/src/sync.rs
similarity index 100%
rename from rust/core/src/blocking.rs
rename to rust/core/src/sync.rs
diff --git a/rust/driver/datafusion/README.md b/rust/driver/datafusion/README.md
index 83a7978afd..0afd6489cc 100644
--- a/rust/driver/datafusion/README.md
+++ b/rust/driver/datafusion/README.md
@@ -30,7 +30,7 @@
 ```rust
 use adbc_core::driver_manager::ManagedDriver;
 use adbc_core::options::AdbcVersion;
-use adbc_core::blocking::{Connection, Database, Driver, Statement};
+use adbc_core::sync::{Connection, Database, Driver, Statement};
 use arrow_cast::pretty::print_batches;
 use arrow_array::RecordBatch;
 
diff --git a/rust/driver/datafusion/src/lib.rs b/rust/driver/datafusion/src/lib.rs
index f25633f1e6..f2f7f16f1b 100644
--- a/rust/driver/datafusion/src/lib.rs
+++ b/rust/driver/datafusion/src/lib.rs
@@ -968,5 +968,5 @@ impl AsyncExecutor for TokioRuntime {
 #[cfg(feature = "ffi")]
 adbc_ffi::export_driver!(
     DataFusionDriverInit,
-    adbc_core::blocking::SyncDriverWrapper::<TokioRuntime, DataFusionDriver>
+    adbc_core::sync::SyncDriverWrapper::<TokioRuntime, DataFusionDriver>
 );
diff --git a/rust/driver/dummy/src/lib.rs b/rust/driver/dummy/src/lib.rs
index 56199e7a72..76cca85f6c 100644
--- a/rust/driver/dummy/src/lib.rs
+++ b/rust/driver/dummy/src/lib.rs
@@ -29,13 +29,14 @@ use arrow_buffer::{OffsetBuffer, ScalarBuffer};
 use arrow_schema::{ArrowError, DataType, Field, Schema, SchemaRef, UnionFields};
 
 use adbc_core::{
-    blocking::{Connection, Database, Driver, Optionable, Statement},
     constants,
     error::{Error, Result, Status},
     options::{
         InfoCode, ObjectDepth, OptionConnection, OptionDatabase, OptionStatement, OptionValue,
     },
-    schemas, PartitionedResult,
+    schemas,
+    sync::{Connection, Database, Driver, Optionable, Statement},
+    PartitionedResult,
 };
 
 #[derive(Debug)]
diff --git a/rust/driver/dummy/tests/driver_exporter_dummy.rs b/rust/driver/dummy/tests/driver_exporter_dummy.rs
index 1e97b7ec74..9eef7e4771 100644
--- a/rust/driver/dummy/tests/driver_exporter_dummy.rs
+++ b/rust/driver/dummy/tests/driver_exporter_dummy.rs
@@ -31,8 +31,8 @@ use adbc_core::options::{
     OptionDatabase, OptionStatement,
 };
 use adbc_core::{
-    blocking::{Connection, Database, Driver, Optionable, Statement},
     schemas,
+    sync::{Connection, Database, Driver, Optionable, Statement},
 };
 use adbc_driver_manager::{ManagedConnection, ManagedDatabase, ManagedDriver, ManagedStatement};
 
diff --git a/rust/driver/snowflake/README.md b/rust/driver/snowflake/README.md
index 6ee962be73..bba5e045a0 100644
--- a/rust/driver/snowflake/README.md
+++ b/rust/driver/snowflake/README.md
@@ -31,7 +31,7 @@ driver, based on the
 ## Example
 
 ```rust,no_run
-use adbc_core::blocking::{Connection, Statement};
+use adbc_core::sync::{Connection, Statement};
 use adbc_snowflake::{connection, database, Driver};
 use arrow_array::{cast::AsArray, types::Decimal128Type};
 
diff --git a/rust/driver/snowflake/src/connection.rs b/rust/driver/snowflake/src/connection.rs
index cee10b4867..706924d900 100644
--- a/rust/driver/snowflake/src/connection.rs
+++ b/rust/driver/snowflake/src/connection.rs
@@ -22,9 +22,9 @@
 use std::collections::HashSet;
 
 use adbc_core::{
-    blocking::Optionable,
     error::Result,
     options::{InfoCode, OptionConnection, OptionValue},
+    sync::Optionable,
 };
 use adbc_driver_manager::ManagedConnection;
 use arrow_array::RecordBatchReader;
@@ -63,7 +63,7 @@ impl Optionable for Connection {
     }
 }
 
-impl adbc_core::blocking::Connection for Connection {
+impl adbc_core::sync::Connection for Connection {
     type StatementType = Statement;
 
     fn new_statement(&mut self) -> Result<Self::StatementType> {
diff --git a/rust/driver/snowflake/src/connection/builder.rs b/rust/driver/snowflake/src/connection/builder.rs
index 62ce7abb7c..6966f200a8 100644
--- a/rust/driver/snowflake/src/connection/builder.rs
+++ b/rust/driver/snowflake/src/connection/builder.rs
@@ -22,9 +22,9 @@
 use std::fmt;
 
 use adbc_core::{
-    blocking::Database as _,
     error::Result,
     options::{OptionConnection, OptionValue},
+    sync::Database as _,
 };
 
 #[cfg(feature = "env")]
diff --git a/rust/driver/snowflake/src/database.rs b/rust/driver/snowflake/src/database.rs
index 14930f7223..cac7ba4ca0 100644
--- a/rust/driver/snowflake/src/database.rs
+++ b/rust/driver/snowflake/src/database.rs
@@ -22,9 +22,9 @@
 use std::{collections::HashSet, ffi::c_int, sync::Arc};
 
 use adbc_core::{
-    blocking::{Connection as _, Database as _, Optionable},
     error::{Error, Result, Status},
     options::{AdbcVersion, InfoCode, OptionConnection, OptionDatabase, OptionValue},
+    sync::{Connection as _, Database as _, Optionable},
 };
 use adbc_driver_manager::ManagedDatabase;
 use arrow_array::{
@@ -165,7 +165,7 @@ impl Optionable for Database {
     }
 }
 
-impl adbc_core::blocking::Database for Database {
+impl adbc_core::sync::Database for Database {
     type ConnectionType = Connection;
 
     fn new_connection(&self) -> Result<Self::ConnectionType> {
diff --git a/rust/driver/snowflake/src/database/builder.rs b/rust/driver/snowflake/src/database/builder.rs
index a320dd3da0..886266cbcb 100644
--- a/rust/driver/snowflake/src/database/builder.rs
+++ b/rust/driver/snowflake/src/database/builder.rs
@@ -25,9 +25,9 @@ use std::env;
 use std::{fmt, path::PathBuf, str::FromStr, time::Duration};
 
 use adbc_core::{
-    blocking::Driver as _,
     error::{Error, Result, Status},
     options::{OptionDatabase, OptionValue},
+    sync::Driver as _,
 };
 use url::{Host, Url};
 
diff --git a/rust/driver/snowflake/src/driver.rs b/rust/driver/snowflake/src/driver.rs
index 546f2a6289..324baacf18 100644
--- a/rust/driver/snowflake/src/driver.rs
+++ b/rust/driver/snowflake/src/driver.rs
@@ -153,7 +153,7 @@ impl Driver {
     }
 }
 
-impl adbc_core::blocking::Driver for Driver {
+impl adbc_core::sync::Driver for Driver {
     type DatabaseType = Database;
 
     fn new_database(&mut self) -> Result<Self::DatabaseType> {
diff --git a/rust/driver/snowflake/src/statement.rs b/rust/driver/snowflake/src/statement.rs
index acfaf1b9ff..4ae93253db 100644
--- a/rust/driver/snowflake/src/statement.rs
+++ b/rust/driver/snowflake/src/statement.rs
@@ -20,7 +20,7 @@
 //!
 
 use adbc_core::{
-    blocking::Optionable,
+    sync::Optionable,
     error::Result,
     options::{OptionStatement, OptionValue},
     PartitionedResult,
@@ -56,7 +56,7 @@ impl Optionable for Statement {
     }
 }
 
-impl adbc_core::blocking::Statement for Statement {
+impl adbc_core::sync::Statement for Statement {
     fn bind(&mut self, batch: RecordBatch) -> Result<()> {
         self.0.bind(batch)
     }
diff --git a/rust/driver/snowflake/tests/driver.rs b/rust/driver/snowflake/tests/driver.rs
index 9b8680a38d..5569a909d8 100644
--- a/rust/driver/snowflake/tests/driver.rs
+++ b/rust/driver/snowflake/tests/driver.rs
@@ -37,9 +37,9 @@ mod tests {
     use std::{collections::HashSet, ops::Deref, sync::LazyLock};
 
     use adbc_core::{
-        blocking::{Connection as _, Statement as _},
         error::{Error, Result},
         options::AdbcVersion,
+        sync::{Connection as _, Statement as _},
     };
     use adbc_snowflake::{connection, database, driver, Connection, Database, Driver, Statement};
     use arrow_array::{cast::AsArray, types::Decimal128Type};
diff --git a/rust/driver_manager/src/lib.rs b/rust/driver_manager/src/lib.rs
index f37b62d03d..fab25557cd 100644
--- a/rust/driver_manager/src/lib.rs
+++ b/rust/driver_manager/src/lib.rs
@@ -50,7 +50,7 @@
 //! # use arrow_select::concat::concat_batches;
 //! # use adbc_core::{
 //! #     options::{AdbcVersion, OptionDatabase, OptionStatement},
-//! #     blocking::{Connection, Database, Driver, Statement, Optionable}
+//! #     sync::{Connection, Database, Driver, Statement, Optionable}
 //! # };
 //! # use adbc_driver_manager::ManagedDriver;
 //! # fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -119,10 +119,10 @@ use arrow_array::{Array, RecordBatch, RecordBatchReader, StructArray};
 use toml::de::DeTable;
 
 use adbc_core::{
-    blocking::{Connection, Database, Driver, Optionable, Statement},
     constants,
     error::{AdbcStatusCode, Error, Result, Status},
     options::{self, AdbcVersion, InfoCode, OptionDatabase, OptionValue},
+    sync::{Connection, Database, Driver, Optionable, Statement},
     LoadFlags, PartitionedResult, LOAD_FLAG_ALLOW_RELATIVE_PATHS, LOAD_FLAG_SEARCH_ENV,
     LOAD_FLAG_SEARCH_SYSTEM, LOAD_FLAG_SEARCH_USER,
 };
diff --git a/rust/driver_manager/tests/common/mod.rs b/rust/driver_manager/tests/common/mod.rs
index 31b8293824..830ca265ab 100644
--- a/rust/driver_manager/tests/common/mod.rs
+++ b/rust/driver_manager/tests/common/mod.rs
@@ -19,7 +19,7 @@ use std::collections::HashSet;
 use std::ops::Deref;
 use std::sync::Arc;
 
-use adbc_core::blocking::{Connection, Database, Driver, Optionable, Statement};
+use adbc_core::sync::{Connection, Database, Driver, Optionable, Statement};
 use adbc_core::error::Status;
 use adbc_core::options::{
     InfoCode, IngestMode, ObjectDepth, OptionConnection, OptionDatabase, OptionStatement,
diff --git a/rust/driver_manager/tests/driver_manager_sqlite.rs b/rust/driver_manager/tests/driver_manager_sqlite.rs
index e155f363d1..3eb8c84eea 100644
--- a/rust/driver_manager/tests/driver_manager_sqlite.rs
+++ b/rust/driver_manager/tests/driver_manager_sqlite.rs
@@ -17,9 +17,9 @@
 
 use arrow_schema::{Field, Schema};
 
-use adbc_core::blocking::{Connection, Database, Driver, Optionable, Statement};
 use adbc_core::error::Status;
 use adbc_core::options::{AdbcVersion, OptionConnection, OptionDatabase};
+use adbc_core::sync::{Connection, Database, Driver, Optionable, Statement};
 use adbc_core::LOAD_FLAG_DEFAULT;
 use adbc_driver_manager::{ManagedDatabase, ManagedDriver};
 
diff --git a/rust/ffi/src/driver_exporter.rs b/rust/ffi/src/driver_exporter.rs
index eaefc6033b..0dca08b127 100644
--- a/rust/ffi/src/driver_exporter.rs
+++ b/rust/ffi/src/driver_exporter.rs
@@ -29,10 +29,10 @@ use super::{
     types::ErrorPrivateData, utils::get_opt_name, FFI_AdbcConnection, FFI_AdbcDatabase,
     FFI_AdbcDriver, FFI_AdbcError, FFI_AdbcErrorDetail, FFI_AdbcPartitions, FFI_AdbcStatement,
 };
-use adbc_core::blocking::{Connection, Database, Driver, Optionable, Statement};
 use adbc_core::constants::ADBC_STATUS_OK;
 use adbc_core::error::{AdbcStatusCode, Error, Result, Status};
 use adbc_core::options::{InfoCode, ObjectDepth, OptionConnection, OptionDatabase, OptionValue};
+use adbc_core::sync::{Connection, Database, Driver, Optionable, Statement};
 
 type DatabaseType<DriverType> = <DriverType as Driver>::DatabaseType;
 type ConnectionType<DriverType> =
diff --git a/rust/ffi/src/lib.rs b/rust/ffi/src/lib.rs
index bf95a8c403..cc75191863 100644
--- a/rust/ffi/src/lib.rs
+++ b/rust/ffi/src/lib.rs
@@ -34,7 +34,7 @@
 //!
 //! The driver exporter allows exposing native Rust drivers as C drivers to be
 //! used by other languages via their own driver manager. Once you have an
-//! implementation of [adbc_core::blocking::Driver], provided that it also implements [Default], you
+//! implementation of [adbc_core::sync::Driver], provided that it also implements [Default], you
 //! can build it as an object file implementing the C API with the
 //! [export_driver] macro.
 

From 485285158c671161e512a9a9bc2d79707abced4f Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Wed, 26 Nov 2025 13:01:00 +0300
Subject: [PATCH 09/14] feat: add RecordBatchStream trait for async traits

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/Cargo.lock                               |   2 +
 rust/Cargo.toml                               |   1 +
 rust/core/Cargo.toml                          |   1 +
 rust/core/src/executor.rs                     |   2 +-
 rust/core/src/non_blocking.rs                 |   2 +
 rust/core/src/non_blocking/local.rs           |  21 ++--
 rust/core/src/non_blocking/send.rs            |  37 ++++---
 rust/core/src/non_blocking/stream.rs          |  29 +++++
 rust/core/src/sync.rs                         | 104 ++++++++++++++++--
 rust/driver/datafusion/Cargo.toml             |   1 +
 rust/driver/datafusion/src/lib.rs             |  64 ++++++-----
 .../datafusion/tests/test_datafusion.rs       |  30 +++--
 12 files changed, 218 insertions(+), 76 deletions(-)
 create mode 100644 rust/core/src/non_blocking/stream.rs

diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 245b6cda53..0fc7638fb6 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -8,6 +8,7 @@ version = "0.22.0"
 dependencies = [
  "arrow-array",
  "arrow-schema",
+ "futures",
 ]
 
 [[package]]
@@ -22,6 +23,7 @@ dependencies = [
  "arrow-select",
  "datafusion",
  "datafusion-substrait",
+ "futures",
  "prost",
  "tokio",
 ]
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index 644769716d..2afbf9bc88 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -43,3 +43,4 @@ arrow-array = { version = ">=53.1.0, <58", default-features = false, features =
 arrow-buffer = { version = ">=53.1.0, <58", default-features = false }
 arrow-schema = { version = ">=53.1.0, <58", default-features = false }
 arrow-select = { version = ">=53.1.0, <58", default-features = false }
+futures = "0.3"
diff --git a/rust/core/Cargo.toml b/rust/core/Cargo.toml
index bd33bf57f5..ab17a68a91 100644
--- a/rust/core/Cargo.toml
+++ b/rust/core/Cargo.toml
@@ -36,6 +36,7 @@ default = []
 [dependencies]
 arrow-array.workspace = true
 arrow-schema.workspace = true
+futures.workspace = true
 
 [package.metadata.docs.rs]
 all-features = true
diff --git a/rust/core/src/executor.rs b/rust/core/src/executor.rs
index dcb45ee7fd..f04073d4ed 100644
--- a/rust/core/src/executor.rs
+++ b/rust/core/src/executor.rs
@@ -17,7 +17,7 @@
 
 use std::{fmt::Debug, future::Future};
 
-pub trait AsyncExecutor: Sized {
+pub trait AsyncExecutor: Sized + Send + Sync {
     type Config: Default;
     type Error: Debug;
 
diff --git a/rust/core/src/non_blocking.rs b/rust/core/src/non_blocking.rs
index 41ac7c32d4..f8972f0736 100644
--- a/rust/core/src/non_blocking.rs
+++ b/rust/core/src/non_blocking.rs
@@ -17,6 +17,8 @@
 
 pub mod local;
 pub mod send;
+pub mod stream;
 
 pub use local::*;
 pub use send::*;
+pub use stream::*;
diff --git a/rust/core/src/non_blocking/local.rs b/rust/core/src/non_blocking/local.rs
index 1788ea14bb..9262bf35b9 100644
--- a/rust/core/src/non_blocking/local.rs
+++ b/rust/core/src/non_blocking/local.rs
@@ -15,13 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow_array::{RecordBatch, RecordBatchReader};
+use arrow_array::RecordBatch;
 use arrow_schema::Schema;
 
 use std::collections::HashSet;
+use std::pin::Pin;
 
 use crate::error::Result;
-use crate::options::*;
+use crate::{options::*, RecordBatchStream};
 
 /// Ability to configure an object by setting/getting options.
 #[allow(async_fn_in_trait)]
@@ -128,7 +129,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
     async fn get_info(
         &self,
         codes: Option<HashSet<InfoCode>>,
-    ) -> Result<impl RecordBatchReader + Send>;
+    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
 
     /// Get a hierarchical view of all catalogs, database schemas, tables, and
     /// columns.
@@ -235,7 +236,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
         table_name: Option<&str>,
         table_type: Option<Vec<&str>>,
         column_name: Option<&str>,
-    ) -> Result<impl RecordBatchReader + Send>;
+    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
 
     /// Get the Arrow schema of a table.
     ///
@@ -260,7 +261,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
     /// Field Name     | Field Type
     /// ---------------|--------------
     /// table_type     | utf8 not null
-    async fn get_table_types(&self) -> Result<impl RecordBatchReader + Send>;
+    async fn get_table_types(&self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
 
     /// Get the names of statistics specific to this driver.
     ///
@@ -275,7 +276,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
     ///
     /// # Since
     /// ADBC API revision 1.1.0
-    async fn get_statistic_names(&self) -> Result<impl RecordBatchReader + Send>;
+    async fn get_statistic_names(&self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
 
     /// Get statistics about the data distribution of table(s).
     ///
@@ -341,7 +342,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
         db_schema: Option<&str>,
         table_name: Option<&str>,
         approximate: bool,
-    ) -> Result<impl RecordBatchReader + Send>;
+    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
 
     /// Commit any pending transactions. Only used if autocommit is disabled.
     ///
@@ -363,7 +364,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
     async fn read_partition(
         &self,
         partition: &[u8],
-    ) -> Result<impl RecordBatchReader + Send + 'static>;
+    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
 }
 
 /// A handle to an async ADBC statement.
@@ -392,7 +393,7 @@ pub trait LocalAsyncStatement: LocalAsyncOptionable<Option = OptionStatement> {
     /// statements.
     // TODO(alexandreyc): should we use a generic here instead of a trait object?
     // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567750972
-    async fn bind_stream(&mut self, reader: Box<dyn RecordBatchReader + Send>) -> Result<()>;
+    async fn bind_stream(&mut self, reader: Pin<Box<dyn RecordBatchStream + Send>>) -> Result<()>;
 
     /// Execute a statement and get the results.
     ///
@@ -400,7 +401,7 @@ pub trait LocalAsyncStatement: LocalAsyncOptionable<Option = OptionStatement> {
     // TODO(alexandreyc): is the Send bound absolutely necessary? same question
     // for all methods that return an impl RecordBatchReader
     // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567748242
-    async fn execute(&mut self) -> Result<impl RecordBatchReader + Send>;
+    async fn execute(&mut self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
 
     /// Execute a statement that doesn’t have a result set and get the number
     /// of affected rows.
diff --git a/rust/core/src/non_blocking/send.rs b/rust/core/src/non_blocking/send.rs
index 0a8e1d4ce6..b5b78b78e7 100644
--- a/rust/core/src/non_blocking/send.rs
+++ b/rust/core/src/non_blocking/send.rs
@@ -15,13 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow_array::{RecordBatch, RecordBatchReader};
+use arrow_array::RecordBatch;
 use arrow_schema::Schema;
 
 use std::collections::HashSet;
+use std::pin::Pin;
 
 use crate::error::Result;
-use crate::options::*;
+use crate::{options::*, RecordBatchStream};
 
 /// Ability to configure an object by setting/getting options.
 pub trait AsyncOptionable: Send {
@@ -200,7 +201,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
     fn get_info(
         &self,
         codes: Option<HashSet<InfoCode>>,
-    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
 
     /// Get a hierarchical view of all catalogs, database schemas, tables, and
     /// columns.
@@ -307,7 +308,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
         table_name: Option<&str>,
         table_type: Option<Vec<&str>>,
         column_name: Option<&str>,
-    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
 
     /// Get the Arrow schema of a table.
     ///
@@ -334,7 +335,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
     /// table_type     | utf8 not null
     fn get_table_types(
         &self,
-    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
 
     /// Get the names of statistics specific to this driver.
     ///
@@ -351,7 +352,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
     /// ADBC API revision 1.1.0
     fn get_statistic_names(
         &self,
-    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
 
     /// Get statistics about the data distribution of table(s).
     ///
@@ -417,7 +418,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
         db_schema: Option<&str>,
         table_name: Option<&str>,
         approximate: bool,
-    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
 
     /// Commit any pending transactions. Only used if autocommit is disabled.
     ///
@@ -439,7 +440,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
     fn read_partition(
         &self,
         partition: &[u8],
-    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send + 'static>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
 }
 
 impl<T: AsyncConnection> super::LocalAsyncConnection for T {
@@ -456,7 +457,7 @@ impl<T: AsyncConnection> super::LocalAsyncConnection for T {
     async fn get_info(
         &self,
         codes: Option<HashSet<InfoCode>>,
-    ) -> Result<impl RecordBatchReader + Send> {
+    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         <Self as AsyncConnection>::get_info(self, codes).await
     }
 
@@ -468,7 +469,7 @@ impl<T: AsyncConnection> super::LocalAsyncConnection for T {
         table_name: Option<&str>,
         table_type: Option<Vec<&str>>,
         column_name: Option<&str>,
-    ) -> Result<impl RecordBatchReader + Send> {
+    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         <Self as AsyncConnection>::get_objects(
             self,
             depth,
@@ -490,11 +491,11 @@ impl<T: AsyncConnection> super::LocalAsyncConnection for T {
         <Self as AsyncConnection>::get_table_schema(self, catalog, db_schema, table_name).await
     }
 
-    async fn get_table_types(&self) -> Result<impl RecordBatchReader + Send> {
+    async fn get_table_types(&self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         <Self as AsyncConnection>::get_table_types(self).await
     }
 
-    async fn get_statistic_names(&self) -> Result<impl RecordBatchReader + Send> {
+    async fn get_statistic_names(&self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         <Self as AsyncConnection>::get_statistic_names(self).await
     }
 
@@ -504,7 +505,7 @@ impl<T: AsyncConnection> super::LocalAsyncConnection for T {
         db_schema: Option<&str>,
         table_name: Option<&str>,
         approximate: bool,
-    ) -> Result<impl RecordBatchReader + Send> {
+    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         <Self as AsyncConnection>::get_statistics(self, catalog, db_schema, table_name, approximate)
             .await
     }
@@ -520,7 +521,7 @@ impl<T: AsyncConnection> super::LocalAsyncConnection for T {
     async fn read_partition(
         &self,
         partition: &[u8],
-    ) -> Result<impl RecordBatchReader + Send + 'static> {
+    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         <Self as AsyncConnection>::read_partition(self, partition).await
     }
 }
@@ -537,7 +538,7 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> + Send {
     // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567750972
     fn bind_stream(
         &mut self,
-        reader: Box<dyn RecordBatchReader + Send>,
+        reader: Pin<Box<dyn RecordBatchStream + Send>>,
     ) -> impl core::future::Future<Output = Result<()>> + Send;
 
     /// Execute a statement and get the results.
@@ -548,7 +549,7 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> + Send {
     // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567748242
     fn execute(
         &mut self,
-    ) -> impl core::future::Future<Output = Result<impl RecordBatchReader + Send>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
 
     /// Execute a statement that doesn’t have a result set and get the number
     /// of affected rows.
@@ -633,11 +634,11 @@ impl<T: AsyncStatement> super::LocalAsyncStatement for T {
         <Self as AsyncStatement>::bind(self, batch).await
     }
 
-    async fn bind_stream(&mut self, reader: Box<dyn RecordBatchReader + Send>) -> Result<()> {
+    async fn bind_stream(&mut self, reader: Pin<Box<dyn RecordBatchStream + Send>>) -> Result<()> {
         <Self as AsyncStatement>::bind_stream(self, reader).await
     }
 
-    async fn execute(&mut self) -> Result<impl RecordBatchReader + Send> {
+    async fn execute(&mut self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         <Self as AsyncStatement>::execute(self).await
     }
 
diff --git a/rust/core/src/non_blocking/stream.rs b/rust/core/src/non_blocking/stream.rs
new file mode 100644
index 0000000000..8d75eb9bce
--- /dev/null
+++ b/rust/core/src/non_blocking/stream.rs
@@ -0,0 +1,29 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+/// Trait for types that stream [RecordBatch]
+///
+/// See [`SendableRecordBatchStream`] for more details.
+pub trait RecordBatchStream:
+    futures::Stream<Item = Result<arrow_array::RecordBatch, arrow_schema::ArrowError>>
+{
+    /// Returns the schema of this `RecordBatchStream`.
+    ///
+    /// Implementation of this trait should guarantee that all `RecordBatch`'s returned by this
+    /// stream should have the same schema as returned from this method.
+    fn schema(&self) -> arrow_schema::SchemaRef;
+}
diff --git a/rust/core/src/sync.rs b/rust/core/src/sync.rs
index 65b53a43da..87722a91ba 100644
--- a/rust/core/src/sync.rs
+++ b/rust/core/src/sync.rs
@@ -16,10 +16,12 @@
 // under the License.
 
 use std::collections::HashSet;
+use std::pin::Pin;
 use std::sync::Arc;
 
 use arrow_array::{RecordBatch, RecordBatchReader};
-use arrow_schema::Schema;
+use arrow_schema::{Schema, SchemaRef};
+use futures::StreamExt;
 
 use crate::error::Result;
 use crate::executor::AsyncExecutor;
@@ -471,11 +473,51 @@ pub trait Statement: Optionable<Option = OptionStatement> {
     fn cancel(&mut self) -> Result<()>;
 }
 
+pub struct SyncRecordBatchStream<A> {
+    executor: Arc<A>,
+    inner: Pin<Box<dyn crate::RecordBatchStream + Send>>,
+}
+
 pub struct SyncDriverWrapper<A, D> {
     inner: D,
     executor: Arc<A>,
 }
 
+impl<A: AsyncExecutor> Iterator for SyncRecordBatchStream<A> {
+    type Item = std::result::Result<RecordBatch, arrow_schema::ArrowError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.executor.block_on(self.inner.next())
+    }
+}
+
+impl<A: AsyncExecutor> RecordBatchReader for SyncRecordBatchStream<A> {
+    fn schema(&self) -> SchemaRef {
+        self.inner.schema()
+    }
+}
+
+pub struct WrapperRecordBatchReader {
+    inner: Box<dyn RecordBatchReader + Send>,
+}
+
+impl futures::Stream for WrapperRecordBatchReader {
+    type Item = std::result::Result<RecordBatch, arrow_schema::ArrowError>;
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        std::task::Poll::Ready(self.get_mut().inner.next())
+    }
+}
+
+impl crate::RecordBatchStream for WrapperRecordBatchReader {
+    fn schema(&self) -> arrow_schema::SchemaRef {
+        self.inner.schema()
+    }
+}
+
 impl<A: AsyncExecutor, D: Default> Default for SyncDriverWrapper<A, D> {
     fn default() -> Self {
         Self {
@@ -638,7 +680,12 @@ where
         &self,
         codes: Option<HashSet<options::InfoCode>>,
     ) -> Result<impl RecordBatchReader + Send> {
-        self.executor.block_on(self.inner.get_info(codes))
+        let reader = self.executor.block_on(self.inner.get_info(codes))?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
     }
 
     fn get_objects(
@@ -650,14 +697,19 @@ where
         table_type: Option<Vec<&str>>,
         column_name: Option<&str>,
     ) -> Result<impl RecordBatchReader + Send> {
-        self.executor.block_on(self.inner.get_objects(
+        let reader = self.executor.block_on(self.inner.get_objects(
             depth,
             catalog,
             db_schema,
             table_name,
             table_type,
             column_name,
-        ))
+        ))?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
     }
 
     fn get_table_schema(
@@ -671,11 +723,21 @@ where
     }
 
     fn get_table_types(&self) -> Result<impl RecordBatchReader + Send> {
-        self.executor.block_on(self.inner.get_table_types())
+        let reader = self.executor.block_on(self.inner.get_table_types())?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
     }
 
     fn get_statistic_names(&self) -> Result<impl RecordBatchReader + Send> {
-        self.executor.block_on(self.inner.get_statistic_names())
+        let reader = self.executor.block_on(self.inner.get_statistic_names())?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
     }
 
     fn get_statistics(
@@ -685,12 +747,17 @@ where
         table_name: Option<&str>,
         approximate: bool,
     ) -> Result<impl RecordBatchReader + Send> {
-        self.executor.block_on(self.inner.get_statistics(
+        let reader = self.executor.block_on(self.inner.get_statistics(
             catalog,
             db_schema,
             table_name,
             approximate,
-        ))
+        ))?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
     }
 
     fn commit(&mut self) -> Result<()> {
@@ -702,7 +769,14 @@ where
     }
 
     fn read_partition(&self, partition: &[u8]) -> Result<impl RecordBatchReader + Send> {
-        self.executor.block_on(self.inner.read_partition(partition))
+        let reader = self
+            .executor
+            .block_on(self.inner.read_partition(partition))?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
     }
 }
 
@@ -749,11 +823,19 @@ where
     }
 
     fn bind_stream(&mut self, reader: Box<dyn RecordBatchReader + Send>) -> Result<()> {
-        self.executor.block_on(self.inner.bind_stream(reader))
+        self.executor.block_on(
+            self.inner
+                .bind_stream(Box::pin(WrapperRecordBatchReader { inner: reader })),
+        )
     }
 
     fn execute(&mut self) -> Result<impl RecordBatchReader + Send> {
-        self.executor.block_on(self.inner.execute())
+        let reader = self.executor.block_on(self.inner.execute())?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
     }
 
     fn execute_update(&mut self) -> Result<Option<i64>> {
diff --git a/rust/driver/datafusion/Cargo.toml b/rust/driver/datafusion/Cargo.toml
index 8b0a1311b9..dab0ccbb55 100644
--- a/rust/driver/datafusion/Cargo.toml
+++ b/rust/driver/datafusion/Cargo.toml
@@ -38,6 +38,7 @@ arrow-buffer = "56.2.0"
 arrow-schema = "56.2.0"
 datafusion = { version = "50.3.0", default-features = false }
 datafusion-substrait = { version = "50.3.0", default-features = false }
+futures.workspace = true
 tokio = { version = "1.48", features = ["rt-multi-thread"] }
 prost = "0.13.5"
 
diff --git a/rust/driver/datafusion/src/lib.rs b/rust/driver/datafusion/src/lib.rs
index f2f7f16f1b..92d3d12ace 100644
--- a/rust/driver/datafusion/src/lib.rs
+++ b/rust/driver/datafusion/src/lib.rs
@@ -18,7 +18,7 @@
 
 use adbc_core::executor::AsyncExecutor;
 use adbc_core::non_blocking::{AsyncConnection, AsyncDatabase, AsyncDriver, AsyncStatement};
-use adbc_core::{constants, options, AsyncOptionable};
+use adbc_core::{constants, options, AsyncOptionable, RecordBatchStream};
 use datafusion::dataframe::DataFrameWriteOptions;
 use datafusion::datasource::TableType;
 use datafusion::prelude::*;
@@ -27,16 +27,16 @@ use datafusion_substrait::substrait::proto::Plan;
 use prost::Message;
 use std::fmt::Debug;
 use std::future::Future;
+use std::pin::Pin;
 use std::sync::Arc;
-use std::vec::IntoIter;
 
 use arrow_array::builder::{
     BooleanBuilder, Int32Builder, Int64Builder, ListBuilder, MapBuilder, MapFieldNames,
     StringBuilder, UInt32Builder,
 };
 use arrow_array::{
-    ArrayRef, BooleanArray, Int16Array, Int32Array, ListArray, RecordBatch, RecordBatchReader,
-    StringArray, StructArray, UnionArray,
+    ArrayRef, BooleanArray, Int16Array, Int32Array, ListArray, RecordBatch, StringArray,
+    StructArray, UnionArray,
 };
 use arrow_buffer::{OffsetBuffer, ScalarBuffer};
 use arrow_schema::{ArrowError, DataType, Field, SchemaRef};
@@ -90,22 +90,25 @@ impl SingleBatchReader {
     }
 }
 
-impl Iterator for SingleBatchReader {
+impl futures::Stream for SingleBatchReader {
     type Item = std::result::Result<RecordBatch, ArrowError>;
 
-    fn next(&mut self) -> Option<Self::Item> {
-        Ok(self.batch.take()).transpose()
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        std::task::Poll::Ready(Ok(self.get_mut().batch.take()).transpose())
     }
 }
 
-impl RecordBatchReader for SingleBatchReader {
+impl RecordBatchStream for SingleBatchReader {
     fn schema(&self) -> SchemaRef {
         self.schema.clone()
     }
 }
 
 pub struct DataFusionReader {
-    batches: IntoIter<RecordBatch>,
+    reader: datafusion::execution::SendableRecordBatchStream,
     schema: SchemaRef,
 }
 
@@ -114,21 +117,29 @@ impl DataFusionReader {
         let schema = df.schema().as_arrow().clone();
 
         Self {
-            batches: df.collect().await.unwrap().into_iter(),
+            reader: df.execute_stream().await.unwrap(),
             schema: schema.into(),
         }
     }
 }
 
-impl Iterator for DataFusionReader {
+impl futures::Stream for DataFusionReader {
     type Item = std::result::Result<RecordBatch, ArrowError>;
 
-    fn next(&mut self) -> Option<Self::Item> {
-        self.batches.next().map(Ok)
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        match self.get_mut().reader.as_mut().poll_next(cx) {
+            std::task::Poll::Ready(item) => {
+                std::task::Poll::Ready(item.map(|batch| batch.map_err(|e| e.into())))
+            }
+            std::task::Poll::Pending => std::task::Poll::Pending,
+        }
     }
 }
 
-impl RecordBatchReader for DataFusionReader {
+impl RecordBatchStream for DataFusionReader {
     fn schema(&self) -> SchemaRef {
         self.schema.clone()
     }
@@ -709,7 +720,7 @@ impl AsyncConnection for DataFusionConnection {
     async fn get_info(
         &self,
         codes: Option<std::collections::HashSet<adbc_core::options::InfoCode>>,
-    ) -> Result<impl RecordBatchReader + Send> {
+    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         let mut get_info_builder = GetInfoBuilder::new();
 
         codes.unwrap().into_iter().for_each(|f| match f {
@@ -722,7 +733,7 @@ impl AsyncConnection for DataFusionConnection {
 
         let batch = get_info_builder.finish()?;
         let reader = SingleBatchReader::new(batch);
-        Ok(reader)
+        Ok(Box::pin(reader))
     }
 
     async fn get_objects(
@@ -733,10 +744,10 @@ impl AsyncConnection for DataFusionConnection {
         _table_name: Option<&str>,
         _table_type: Option<Vec<&str>>,
         _column_name: Option<&str>,
-    ) -> Result<impl RecordBatchReader + Send> {
+    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         let batch = GetObjectsBuilder::new().build(&self.ctx, &depth).await?;
         let reader = SingleBatchReader::new(batch);
-        Ok(reader)
+        Ok(Box::pin(reader))
     }
 
     async fn get_table_schema(
@@ -748,11 +759,11 @@ impl AsyncConnection for DataFusionConnection {
         todo!()
     }
 
-    async fn get_table_types(&self) -> Result<SingleBatchReader> {
+    async fn get_table_types(&self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         todo!()
     }
 
-    async fn get_statistic_names(&self) -> Result<SingleBatchReader> {
+    async fn get_statistic_names(&self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         todo!()
     }
 
@@ -762,7 +773,7 @@ impl AsyncConnection for DataFusionConnection {
         _db_schema: Option<&str>,
         _table_name: Option<&str>,
         _approximate: bool,
-    ) -> Result<SingleBatchReader> {
+    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         todo!()
     }
 
@@ -774,7 +785,10 @@ impl AsyncConnection for DataFusionConnection {
         todo!()
     }
 
-    async fn read_partition(&self, _partition: &[u8]) -> Result<SingleBatchReader> {
+    async fn read_partition(
+        &self,
+        _partition: &[u8],
+    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         todo!()
     }
 }
@@ -862,12 +876,12 @@ impl AsyncStatement for DataFusionStatement {
 
     async fn bind_stream(
         &mut self,
-        _reader: Box<dyn arrow_array::RecordBatchReader + Send>,
+        _reader: Pin<Box<dyn RecordBatchStream + Send>>,
     ) -> adbc_core::error::Result<()> {
         todo!()
     }
 
-    async fn execute(&mut self) -> Result<impl RecordBatchReader + Send> {
+    async fn execute(&mut self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
         let df = if self.sql_query.is_some() {
             self.ctx
                 .sql(&self.sql_query.clone().unwrap())
@@ -881,7 +895,7 @@ impl AsyncStatement for DataFusionStatement {
             self.ctx.execute_logical_plan(plan).await.unwrap()
         };
 
-        Ok(DataFusionReader::new(df).await)
+        Ok(Box::pin(DataFusionReader::new(df).await))
     }
 
     async fn execute_update(&mut self) -> adbc_core::error::Result<Option<i64>> {
diff --git a/rust/driver/datafusion/tests/test_datafusion.rs b/rust/driver/datafusion/tests/test_datafusion.rs
index 7f76c466c9..ad3f5edb3b 100644
--- a/rust/driver/datafusion/tests/test_datafusion.rs
+++ b/rust/driver/datafusion/tests/test_datafusion.rs
@@ -15,9 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::pin::Pin;
+
 use adbc_core::non_blocking::{
     AsyncConnection, AsyncDatabase, AsyncDriver, AsyncStatement, LocalAsyncOptionable,
 };
+use adbc_core::RecordBatchStream;
 use adbc_datafusion::{DataFusionConnection, DataFusionDriver};
 use arrow_array::RecordBatch;
 use datafusion::prelude::*;
@@ -26,8 +29,19 @@ use adbc_core::options::{OptionConnection, OptionStatement, OptionValue};
 use arrow_select::concat::concat_batches;
 use datafusion_substrait::logical_plan::producer::to_substrait_plan;
 use datafusion_substrait::substrait::proto::Plan;
+use futures::StreamExt;
 use prost::Message;
 
+async fn read_all_record_batches(
+    mut reader: Pin<Box<dyn RecordBatchStream + Send>>,
+) -> adbc_core::error::Result<Vec<RecordBatch>> {
+    let mut batches = Vec::new();
+    while let Some(batch) = reader.next().await {
+        batches.push(batch?);
+    }
+    Ok(batches)
+}
+
 async fn get_connection() -> DataFusionConnection {
     let mut driver = DataFusionDriver::default();
     let database = driver.new_database().await.unwrap();
@@ -46,7 +60,7 @@ async fn get_objects(connection: &DataFusionConnection) -> RecordBatch {
         )
         .await;
 
-    let batches: Vec<RecordBatch> = objects.unwrap().map(|b| b.unwrap()).collect();
+    let batches = read_all_record_batches(objects.unwrap()).await.unwrap();
 
     let schema = batches.first().unwrap().schema();
 
@@ -63,12 +77,9 @@ async fn execute_sql_query(connection: &mut DataFusionConnection, query: &str) -
     let mut statement = connection.new_statement().await.unwrap();
     let _ = statement.set_sql_query(query).await;
 
-    let batches: Vec<RecordBatch> = statement
-        .execute()
+    let batches = read_all_record_batches(statement.execute().await.unwrap())
         .await
-        .unwrap()
-        .map(|b| b.unwrap())
-        .collect();
+        .unwrap();
 
     let schema = batches.first().unwrap().schema();
 
@@ -80,12 +91,9 @@ async fn execute_substrait(connection: &mut DataFusionConnection, plan: Plan) ->
 
     let _ = statement.set_substrait_plan(&plan.encode_to_vec()).await;
 
-    let batches: Vec<RecordBatch> = statement
-        .execute()
+    let batches = read_all_record_batches(statement.execute().await.unwrap())
         .await
-        .unwrap()
-        .map(|b| b.unwrap())
-        .collect();
+        .unwrap();
 
     let schema = batches.first().unwrap().schema();
 

From 6f93a8812460936983a283354c3a0e5b89e7e5ec Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Wed, 26 Nov 2025 13:16:24 +0300
Subject: [PATCH 10/14] fix: fmt

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/driver/snowflake/src/statement.rs  | 2 +-
 rust/driver_manager/tests/common/mod.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/rust/driver/snowflake/src/statement.rs b/rust/driver/snowflake/src/statement.rs
index 4ae93253db..cc8692dca3 100644
--- a/rust/driver/snowflake/src/statement.rs
+++ b/rust/driver/snowflake/src/statement.rs
@@ -20,9 +20,9 @@
 //!
 
 use adbc_core::{
-    sync::Optionable,
     error::Result,
     options::{OptionStatement, OptionValue},
+    sync::Optionable,
     PartitionedResult,
 };
 use adbc_driver_manager::ManagedStatement;
diff --git a/rust/driver_manager/tests/common/mod.rs b/rust/driver_manager/tests/common/mod.rs
index 830ca265ab..b07629d7da 100644
--- a/rust/driver_manager/tests/common/mod.rs
+++ b/rust/driver_manager/tests/common/mod.rs
@@ -19,12 +19,12 @@ use std::collections::HashSet;
 use std::ops::Deref;
 use std::sync::Arc;
 
-use adbc_core::sync::{Connection, Database, Driver, Optionable, Statement};
 use adbc_core::error::Status;
 use adbc_core::options::{
     InfoCode, IngestMode, ObjectDepth, OptionConnection, OptionDatabase, OptionStatement,
 };
 use adbc_core::schemas;
+use adbc_core::sync::{Connection, Database, Driver, Optionable, Statement};
 use adbc_driver_manager::{ManagedConnection, ManagedDatabase, ManagedDriver, ManagedStatement};
 
 use arrow_array::{

From 9706b6fc8eed9d5dbc0d4b5905bfed6f67c90b77 Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Wed, 26 Nov 2025 13:22:11 +0300
Subject: [PATCH 11/14] fix: docs

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/core/src/non_blocking/local.rs  | 24 ++++++++++++------------
 rust/core/src/non_blocking/send.rs   |  4 ++--
 rust/core/src/non_blocking/stream.rs |  4 +---
 3 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/rust/core/src/non_blocking/local.rs b/rust/core/src/non_blocking/local.rs
index 9262bf35b9..15d4d24a45 100644
--- a/rust/core/src/non_blocking/local.rs
+++ b/rust/core/src/non_blocking/local.rs
@@ -89,7 +89,7 @@ pub trait LocalAsyncDatabase: LocalAsyncOptionable<Option = OptionDatabase> {
 /// # Autocommit
 ///
 /// Connections should start in autocommit mode. They can be moved out by
-/// setting [options::OptionConnection::AutoCommit] to "false". Turning off
+/// setting [crate::options::OptionConnection::AutoCommit] to "false". Turning off
 /// autocommit allows customizing the isolation level.
 #[allow(async_fn_in_trait)]
 pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection> {
@@ -147,7 +147,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
     ///   filter by name. May be a search pattern.
     /// - `table_type` - Only show tables matching one of the given table
     ///   types. If `None`, show tables of any type. Valid table types can be fetched
-    ///   from [AsyncConnection::get_table_types].
+    ///   from [LocalAsyncConnection::get_table_types].
     /// - `column_name` - Only show columns with the given name. If
     ///   `None`, do not filter by name.  May be a search pattern..
     ///
@@ -320,8 +320,8 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
     /// 2. A dictionary-encoded statistic name (although we do not use the Arrow
     ///    dictionary type). Values in [0, 1024) are reserved for ADBC.  Other
     ///    values are for implementation-specific statistics.  For the definitions
-    ///    of predefined statistic types, see [options::Statistics]. To get
-    ///    driver-specific statistic names, use [AsyncConnection::get_statistic_names].
+    ///    of predefined statistic types, see [crate::options::Statistics]. To get
+    ///    driver-specific statistic names, use [LocalAsyncConnection::get_statistic_names].
     /// 3. If true, then the value is approximate or best-effort.
     ///
     /// VALUE_SCHEMA is a dense union with members:
@@ -356,7 +356,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
 
     /// Retrieve a given partition of data.
     ///
-    /// A partition can be retrieved from [AsyncStatement::execute_partitions].
+    /// A partition can be retrieved from [LocalAsyncStatement::execute_partitions].
     ///
     /// # Arguments
     ///
@@ -419,7 +419,7 @@ pub trait LocalAsyncStatement: LocalAsyncOptionable<Option = OptionStatement> {
     /// This invalidates any prior result sets.
     ///
     /// Depending on the driver, this may require first executing
-    /// [AsyncStatement::prepare].
+    /// [LocalAsyncStatement::prepare].
     ///
     /// # Since
     ///
@@ -441,7 +441,7 @@ pub trait LocalAsyncStatement: LocalAsyncOptionable<Option = OptionStatement> {
     /// be an empty string. If the type cannot be determined, the type of
     /// the corresponding field will be NA (NullType).
     ///
-    /// This should be called after [AsyncStatement::prepare].
+    /// This should be called after [LocalAsyncStatement::prepare].
     async fn get_parameter_schema(&self) -> Result<Schema>;
 
     /// Turn this statement into a prepared statement to be executed multiple
@@ -452,19 +452,19 @@ pub trait LocalAsyncStatement: LocalAsyncOptionable<Option = OptionStatement> {
 
     /// Set the SQL query to execute.
     ///
-    /// The query can then be executed with [AsyncStatement::execute]. For queries
-    /// expected to be executed repeatedly, call [AsyncStatement::prepare] first.
+    /// The query can then be executed with [LocalAsyncStatement::execute]. For queries
+    /// expected to be executed repeatedly, call [LocalAsyncStatement::prepare] first.
     async fn set_sql_query(&mut self, query: &str) -> Result<()>;
 
     /// Set the Substrait plan to execute.
     ///
-    /// The query can then be executed with [AsyncStatement::execute]. For queries
-    /// expected to be executed repeatedly, call [AsyncStatement::prepare] first.
+    /// The query can then be executed with [LocalAsyncStatement::execute]. For queries
+    /// expected to be executed repeatedly, call [LocalAsyncStatement::prepare] first.
     async fn set_substrait_plan(&mut self, plan: &[u8]) -> Result<()>;
 
     /// Cancel execution of an in-progress query.
     ///
-    /// This can be called during [AsyncStatement::execute] (or similar), or while
+    /// This can be called during [LocalAsyncStatement::execute] (or similar), or while
     /// consuming a result set returned from such.
     ///
     /// # Since
diff --git a/rust/core/src/non_blocking/send.rs b/rust/core/src/non_blocking/send.rs
index b5b78b78e7..5701f8f21f 100644
--- a/rust/core/src/non_blocking/send.rs
+++ b/rust/core/src/non_blocking/send.rs
@@ -160,7 +160,7 @@ impl<T: AsyncDatabase> super::LocalAsyncDatabase for T {
 /// # Autocommit
 ///
 /// Connections should start in autocommit mode. They can be moved out by
-/// setting [options::OptionConnection::AutoCommit] to "false". Turning off
+/// setting [crate::options::OptionConnection::AutoCommit] to "false". Turning off
 /// autocommit allows customizing the isolation level.
 pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
     type StatementType: AsyncStatement;
@@ -396,7 +396,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
     /// 2. A dictionary-encoded statistic name (although we do not use the Arrow
     ///    dictionary type). Values in [0, 1024) are reserved for ADBC.  Other
     ///    values are for implementation-specific statistics.  For the definitions
-    ///    of predefined statistic types, see [options::Statistics]. To get
+    ///    of predefined statistic types, see [crate::options::Statistics]. To get
     ///    driver-specific statistic names, use [AsyncConnection::get_statistic_names].
     /// 3. If true, then the value is approximate or best-effort.
     ///
diff --git a/rust/core/src/non_blocking/stream.rs b/rust/core/src/non_blocking/stream.rs
index 8d75eb9bce..f4e592d826 100644
--- a/rust/core/src/non_blocking/stream.rs
+++ b/rust/core/src/non_blocking/stream.rs
@@ -15,9 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-/// Trait for types that stream [RecordBatch]
-///
-/// See [`SendableRecordBatchStream`] for more details.
+/// Trait for types that stream [arrow_array::RecordBatch]
 pub trait RecordBatchStream:
     futures::Stream<Item = Result<arrow_array::RecordBatch, arrow_schema::ArrowError>>
 {

From 6da2a965f7e6d8e5f662ff895b6ed6d66ed3fc70 Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Thu, 27 Nov 2025 10:59:20 +0300
Subject: [PATCH 12/14] changes: sync traits by default

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/core/src/lib.rs                          |  2 +-
 rust/core/src/non_blocking/local.rs           | 21 ++++++-----
 rust/core/src/non_blocking/send.rs            | 37 ++++++++++---------
 rust/core/src/sync.rs                         |  8 ++--
 rust/driver/datafusion/README.md              |  2 +-
 rust/driver/datafusion/src/lib.rs             |  8 +++-
 .../datafusion/tests/test_datafusion.rs       |  2 +-
 rust/driver/dummy/src/lib.rs                  |  4 +-
 .../dummy/tests/driver_exporter_dummy.rs      |  5 +--
 rust/driver/snowflake/README.md               |  2 +-
 rust/driver/snowflake/src/statement.rs        |  5 +--
 rust/driver/snowflake/tests/driver.rs         |  2 +-
 rust/driver_manager/src/lib.rs                |  6 +--
 rust/driver_manager/tests/common/mod.rs       |  2 +-
 .../tests/driver_manager_sqlite.rs            |  2 +-
 rust/ffi/src/driver_exporter.rs               |  2 +-
 rust/ffi/src/lib.rs                           |  2 +-
 17 files changed, 58 insertions(+), 54 deletions(-)

diff --git a/rust/core/src/lib.rs b/rust/core/src/lib.rs
index 7f2ee79e88..f53e5b4ecc 100644
--- a/rust/core/src/lib.rs
+++ b/rust/core/src/lib.rs
@@ -47,7 +47,7 @@ pub mod options;
 pub mod schemas;
 pub mod sync;
 
-pub use non_blocking::*;
+pub use sync::*;
 
 pub type LoadFlags = u32;
 
diff --git a/rust/core/src/non_blocking/local.rs b/rust/core/src/non_blocking/local.rs
index 15d4d24a45..dcf18302b9 100644
--- a/rust/core/src/non_blocking/local.rs
+++ b/rust/core/src/non_blocking/local.rs
@@ -22,7 +22,7 @@ use std::collections::HashSet;
 use std::pin::Pin;
 
 use crate::error::Result;
-use crate::{options::*, RecordBatchStream};
+use crate::options::*;
 
 /// Ability to configure an object by setting/getting options.
 #[allow(async_fn_in_trait)]
@@ -129,7 +129,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
     async fn get_info(
         &self,
         codes: Option<HashSet<InfoCode>>,
-    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
+    ) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>>;
 
     /// Get a hierarchical view of all catalogs, database schemas, tables, and
     /// columns.
@@ -236,7 +236,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
         table_name: Option<&str>,
         table_type: Option<Vec<&str>>,
         column_name: Option<&str>,
-    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
+    ) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>>;
 
     /// Get the Arrow schema of a table.
     ///
@@ -261,7 +261,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
     /// Field Name     | Field Type
     /// ---------------|--------------
     /// table_type     | utf8 not null
-    async fn get_table_types(&self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
+    async fn get_table_types(&self) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>>;
 
     /// Get the names of statistics specific to this driver.
     ///
@@ -276,7 +276,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
     ///
     /// # Since
     /// ADBC API revision 1.1.0
-    async fn get_statistic_names(&self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
+    async fn get_statistic_names(&self) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>>;
 
     /// Get statistics about the data distribution of table(s).
     ///
@@ -342,7 +342,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
         db_schema: Option<&str>,
         table_name: Option<&str>,
         approximate: bool,
-    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
+    ) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>>;
 
     /// Commit any pending transactions. Only used if autocommit is disabled.
     ///
@@ -364,7 +364,7 @@ pub trait LocalAsyncConnection: LocalAsyncOptionable<Option = OptionConnection>
     async fn read_partition(
         &self,
         partition: &[u8],
-    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
+    ) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>>;
 }
 
 /// A handle to an async ADBC statement.
@@ -393,7 +393,10 @@ pub trait LocalAsyncStatement: LocalAsyncOptionable<Option = OptionStatement> {
     /// statements.
     // TODO(alexandreyc): should we use a generic here instead of a trait object?
     // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567750972
-    async fn bind_stream(&mut self, reader: Pin<Box<dyn RecordBatchStream + Send>>) -> Result<()>;
+    async fn bind_stream(
+        &mut self,
+        reader: Pin<Box<dyn super::RecordBatchStream + Send>>,
+    ) -> Result<()>;
 
     /// Execute a statement and get the results.
     ///
@@ -401,7 +404,7 @@ pub trait LocalAsyncStatement: LocalAsyncOptionable<Option = OptionStatement> {
     // TODO(alexandreyc): is the Send bound absolutely necessary? same question
     // for all methods that return an impl RecordBatchReader
     // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567748242
-    async fn execute(&mut self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>>;
+    async fn execute(&mut self) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>>;
 
     /// Execute a statement that doesn’t have a result set and get the number
     /// of affected rows.
diff --git a/rust/core/src/non_blocking/send.rs b/rust/core/src/non_blocking/send.rs
index 5701f8f21f..adb0e46691 100644
--- a/rust/core/src/non_blocking/send.rs
+++ b/rust/core/src/non_blocking/send.rs
@@ -22,7 +22,7 @@ use std::collections::HashSet;
 use std::pin::Pin;
 
 use crate::error::Result;
-use crate::{options::*, RecordBatchStream};
+use crate::options::*;
 
 /// Ability to configure an object by setting/getting options.
 pub trait AsyncOptionable: Send {
@@ -201,7 +201,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
     fn get_info(
         &self,
         codes: Option<HashSet<InfoCode>>,
-    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn super::RecordBatchStream + Send>>>> + Send;
 
     /// Get a hierarchical view of all catalogs, database schemas, tables, and
     /// columns.
@@ -308,7 +308,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
         table_name: Option<&str>,
         table_type: Option<Vec<&str>>,
         column_name: Option<&str>,
-    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn super::RecordBatchStream + Send>>>> + Send;
 
     /// Get the Arrow schema of a table.
     ///
@@ -335,7 +335,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
     /// table_type     | utf8 not null
     fn get_table_types(
         &self,
-    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn super::RecordBatchStream + Send>>>> + Send;
 
     /// Get the names of statistics specific to this driver.
     ///
@@ -352,7 +352,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
     /// ADBC API revision 1.1.0
     fn get_statistic_names(
         &self,
-    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn super::RecordBatchStream + Send>>>> + Send;
 
     /// Get statistics about the data distribution of table(s).
     ///
@@ -418,7 +418,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
         db_schema: Option<&str>,
         table_name: Option<&str>,
         approximate: bool,
-    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn super::RecordBatchStream + Send>>>> + Send;
 
     /// Commit any pending transactions. Only used if autocommit is disabled.
     ///
@@ -440,7 +440,7 @@ pub trait AsyncConnection: AsyncOptionable<Option = OptionConnection> + Send {
     fn read_partition(
         &self,
         partition: &[u8],
-    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn super::RecordBatchStream + Send>>>> + Send;
 }
 
 impl<T: AsyncConnection> super::LocalAsyncConnection for T {
@@ -457,7 +457,7 @@ impl<T: AsyncConnection> super::LocalAsyncConnection for T {
     async fn get_info(
         &self,
         codes: Option<HashSet<InfoCode>>,
-    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
+    ) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>> {
         <Self as AsyncConnection>::get_info(self, codes).await
     }
 
@@ -469,7 +469,7 @@ impl<T: AsyncConnection> super::LocalAsyncConnection for T {
         table_name: Option<&str>,
         table_type: Option<Vec<&str>>,
         column_name: Option<&str>,
-    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
+    ) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>> {
         <Self as AsyncConnection>::get_objects(
             self,
             depth,
@@ -491,11 +491,11 @@ impl<T: AsyncConnection> super::LocalAsyncConnection for T {
         <Self as AsyncConnection>::get_table_schema(self, catalog, db_schema, table_name).await
     }
 
-    async fn get_table_types(&self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
+    async fn get_table_types(&self) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>> {
         <Self as AsyncConnection>::get_table_types(self).await
     }
 
-    async fn get_statistic_names(&self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
+    async fn get_statistic_names(&self) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>> {
         <Self as AsyncConnection>::get_statistic_names(self).await
     }
 
@@ -505,7 +505,7 @@ impl<T: AsyncConnection> super::LocalAsyncConnection for T {
         db_schema: Option<&str>,
         table_name: Option<&str>,
         approximate: bool,
-    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
+    ) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>> {
         <Self as AsyncConnection>::get_statistics(self, catalog, db_schema, table_name, approximate)
             .await
     }
@@ -521,7 +521,7 @@ impl<T: AsyncConnection> super::LocalAsyncConnection for T {
     async fn read_partition(
         &self,
         partition: &[u8],
-    ) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
+    ) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>> {
         <Self as AsyncConnection>::read_partition(self, partition).await
     }
 }
@@ -538,7 +538,7 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> + Send {
     // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567750972
     fn bind_stream(
         &mut self,
-        reader: Pin<Box<dyn RecordBatchStream + Send>>,
+        reader: Pin<Box<dyn super::RecordBatchStream + Send>>,
     ) -> impl core::future::Future<Output = Result<()>> + Send;
 
     /// Execute a statement and get the results.
@@ -549,7 +549,7 @@ pub trait AsyncStatement: AsyncOptionable<Option = OptionStatement> + Send {
     // See: https://github.com/apache/arrow-adbc/pull/1725#discussion_r1567748242
     fn execute(
         &mut self,
-    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn RecordBatchStream + Send>>>> + Send;
+    ) -> impl core::future::Future<Output = Result<Pin<Box<dyn super::RecordBatchStream + Send>>>> + Send;
 
     /// Execute a statement that doesn’t have a result set and get the number
     /// of affected rows.
@@ -634,11 +634,14 @@ impl<T: AsyncStatement> super::LocalAsyncStatement for T {
         <Self as AsyncStatement>::bind(self, batch).await
     }
 
-    async fn bind_stream(&mut self, reader: Pin<Box<dyn RecordBatchStream + Send>>) -> Result<()> {
+    async fn bind_stream(
+        &mut self,
+        reader: Pin<Box<dyn super::RecordBatchStream + Send>>,
+    ) -> Result<()> {
         <Self as AsyncStatement>::bind_stream(self, reader).await
     }
 
-    async fn execute(&mut self) -> Result<Pin<Box<dyn RecordBatchStream + Send>>> {
+    async fn execute(&mut self) -> Result<Pin<Box<dyn super::RecordBatchStream + Send>>> {
         <Self as AsyncStatement>::execute(self).await
     }
 
diff --git a/rust/core/src/sync.rs b/rust/core/src/sync.rs
index 87722a91ba..061695616d 100644
--- a/rust/core/src/sync.rs
+++ b/rust/core/src/sync.rs
@@ -25,11 +25,11 @@ use futures::StreamExt;
 
 use crate::error::Result;
 use crate::executor::AsyncExecutor;
-use crate::options::{self, OptionConnection, OptionDatabase, OptionStatement, OptionValue};
-use crate::{
+use crate::non_blocking::{
     LocalAsyncConnection, LocalAsyncDatabase, LocalAsyncDriver, LocalAsyncOptionable,
     LocalAsyncStatement,
 };
+use crate::options::{self, OptionConnection, OptionDatabase, OptionStatement, OptionValue};
 
 /// Ability to configure an object by setting/getting options.
 pub trait Optionable {
@@ -475,7 +475,7 @@ pub trait Statement: Optionable<Option = OptionStatement> {
 
 pub struct SyncRecordBatchStream<A> {
     executor: Arc<A>,
-    inner: Pin<Box<dyn crate::RecordBatchStream + Send>>,
+    inner: Pin<Box<dyn crate::non_blocking::RecordBatchStream + Send>>,
 }
 
 pub struct SyncDriverWrapper<A, D> {
@@ -512,7 +512,7 @@ impl futures::Stream for WrapperRecordBatchReader {
     }
 }
 
-impl crate::RecordBatchStream for WrapperRecordBatchReader {
+impl crate::non_blocking::RecordBatchStream for WrapperRecordBatchReader {
     fn schema(&self) -> arrow_schema::SchemaRef {
         self.inner.schema()
     }
diff --git a/rust/driver/datafusion/README.md b/rust/driver/datafusion/README.md
index 0afd6489cc..4d1ea5d0b0 100644
--- a/rust/driver/datafusion/README.md
+++ b/rust/driver/datafusion/README.md
@@ -30,7 +30,7 @@
 ```rust
 use adbc_core::driver_manager::ManagedDriver;
 use adbc_core::options::AdbcVersion;
-use adbc_core::sync::{Connection, Database, Driver, Statement};
+use adbc_core::{Connection, Database, Driver, Statement};
 use arrow_cast::pretty::print_batches;
 use arrow_array::RecordBatch;
 
diff --git a/rust/driver/datafusion/src/lib.rs b/rust/driver/datafusion/src/lib.rs
index 92d3d12ace..68d58b3964 100644
--- a/rust/driver/datafusion/src/lib.rs
+++ b/rust/driver/datafusion/src/lib.rs
@@ -18,7 +18,11 @@
 
 use adbc_core::executor::AsyncExecutor;
 use adbc_core::non_blocking::{AsyncConnection, AsyncDatabase, AsyncDriver, AsyncStatement};
-use adbc_core::{constants, options, AsyncOptionable, RecordBatchStream};
+use adbc_core::{
+    constants,
+    non_blocking::{AsyncOptionable, RecordBatchStream},
+    options,
+};
 use datafusion::dataframe::DataFrameWriteOptions;
 use datafusion::datasource::TableType;
 use datafusion::prelude::*;
@@ -982,5 +986,5 @@ impl AsyncExecutor for TokioRuntime {
 #[cfg(feature = "ffi")]
 adbc_ffi::export_driver!(
     DataFusionDriverInit,
-    adbc_core::sync::SyncDriverWrapper::<TokioRuntime, DataFusionDriver>
+    adbc_core::SyncDriverWrapper::<TokioRuntime, DataFusionDriver>
 );
diff --git a/rust/driver/datafusion/tests/test_datafusion.rs b/rust/driver/datafusion/tests/test_datafusion.rs
index ad3f5edb3b..c5e9159d6a 100644
--- a/rust/driver/datafusion/tests/test_datafusion.rs
+++ b/rust/driver/datafusion/tests/test_datafusion.rs
@@ -17,10 +17,10 @@
 
 use std::pin::Pin;
 
+use adbc_core::non_blocking::RecordBatchStream;
 use adbc_core::non_blocking::{
     AsyncConnection, AsyncDatabase, AsyncDriver, AsyncStatement, LocalAsyncOptionable,
 };
-use adbc_core::RecordBatchStream;
 use adbc_datafusion::{DataFusionConnection, DataFusionDriver};
 use arrow_array::RecordBatch;
 use datafusion::prelude::*;
diff --git a/rust/driver/dummy/src/lib.rs b/rust/driver/dummy/src/lib.rs
index 76cca85f6c..d600e65e37 100644
--- a/rust/driver/dummy/src/lib.rs
+++ b/rust/driver/dummy/src/lib.rs
@@ -34,9 +34,7 @@ use adbc_core::{
     options::{
         InfoCode, ObjectDepth, OptionConnection, OptionDatabase, OptionStatement, OptionValue,
     },
-    schemas,
-    sync::{Connection, Database, Driver, Optionable, Statement},
-    PartitionedResult,
+    schemas, Connection, Database, Driver, Optionable, PartitionedResult, Statement,
 };
 
 #[derive(Debug)]
diff --git a/rust/driver/dummy/tests/driver_exporter_dummy.rs b/rust/driver/dummy/tests/driver_exporter_dummy.rs
index 9eef7e4771..3a6db400ca 100644
--- a/rust/driver/dummy/tests/driver_exporter_dummy.rs
+++ b/rust/driver/dummy/tests/driver_exporter_dummy.rs
@@ -30,10 +30,7 @@ use adbc_core::options::{
     AdbcVersion, InfoCode, IngestMode, IsolationLevel, ObjectDepth, OptionConnection,
     OptionDatabase, OptionStatement,
 };
-use adbc_core::{
-    schemas,
-    sync::{Connection, Database, Driver, Optionable, Statement},
-};
+use adbc_core::{schemas, Connection, Database, Driver, Optionable, Statement};
 use adbc_driver_manager::{ManagedConnection, ManagedDatabase, ManagedDriver, ManagedStatement};
 
 use adbc_dummy::{DummyConnection, DummyDatabase, DummyDriver, DummyStatement, SingleBatchReader};
diff --git a/rust/driver/snowflake/README.md b/rust/driver/snowflake/README.md
index bba5e045a0..1146036625 100644
--- a/rust/driver/snowflake/README.md
+++ b/rust/driver/snowflake/README.md
@@ -31,7 +31,7 @@ driver, based on the
 ## Example
 
 ```rust,no_run
-use adbc_core::sync::{Connection, Statement};
+use adbc_core::{Connection, Statement};
 use adbc_snowflake::{connection, database, Driver};
 use arrow_array::{cast::AsArray, types::Decimal128Type};
 
diff --git a/rust/driver/snowflake/src/statement.rs b/rust/driver/snowflake/src/statement.rs
index cc8692dca3..eb41d1108f 100644
--- a/rust/driver/snowflake/src/statement.rs
+++ b/rust/driver/snowflake/src/statement.rs
@@ -22,8 +22,7 @@
 use adbc_core::{
     error::Result,
     options::{OptionStatement, OptionValue},
-    sync::Optionable,
-    PartitionedResult,
+    Optionable, PartitionedResult,
 };
 use adbc_driver_manager::ManagedStatement;
 use arrow_array::{RecordBatch, RecordBatchReader};
@@ -56,7 +55,7 @@ impl Optionable for Statement {
     }
 }
 
-impl adbc_core::sync::Statement for Statement {
+impl adbc_core::Statement for Statement {
     fn bind(&mut self, batch: RecordBatch) -> Result<()> {
         self.0.bind(batch)
     }
diff --git a/rust/driver/snowflake/tests/driver.rs b/rust/driver/snowflake/tests/driver.rs
index 5569a909d8..a5eaec7561 100644
--- a/rust/driver/snowflake/tests/driver.rs
+++ b/rust/driver/snowflake/tests/driver.rs
@@ -39,7 +39,7 @@ mod tests {
     use adbc_core::{
         error::{Error, Result},
         options::AdbcVersion,
-        sync::{Connection as _, Statement as _},
+        Connection as _, Statement as _,
     };
     use adbc_snowflake::{connection, database, driver, Connection, Database, Driver, Statement};
     use arrow_array::{cast::AsArray, types::Decimal128Type};
diff --git a/rust/driver_manager/src/lib.rs b/rust/driver_manager/src/lib.rs
index fab25557cd..310ef47413 100644
--- a/rust/driver_manager/src/lib.rs
+++ b/rust/driver_manager/src/lib.rs
@@ -122,9 +122,9 @@ use adbc_core::{
     constants,
     error::{AdbcStatusCode, Error, Result, Status},
     options::{self, AdbcVersion, InfoCode, OptionDatabase, OptionValue},
-    sync::{Connection, Database, Driver, Optionable, Statement},
-    LoadFlags, PartitionedResult, LOAD_FLAG_ALLOW_RELATIVE_PATHS, LOAD_FLAG_SEARCH_ENV,
-    LOAD_FLAG_SEARCH_SYSTEM, LOAD_FLAG_SEARCH_USER,
+    Connection, Database, Driver, LoadFlags, Optionable, PartitionedResult, Statement,
+    LOAD_FLAG_ALLOW_RELATIVE_PATHS, LOAD_FLAG_SEARCH_ENV, LOAD_FLAG_SEARCH_SYSTEM,
+    LOAD_FLAG_SEARCH_USER,
 };
 use adbc_ffi::driver_method;
 
diff --git a/rust/driver_manager/tests/common/mod.rs b/rust/driver_manager/tests/common/mod.rs
index b07629d7da..28df83f104 100644
--- a/rust/driver_manager/tests/common/mod.rs
+++ b/rust/driver_manager/tests/common/mod.rs
@@ -24,7 +24,7 @@ use adbc_core::options::{
     InfoCode, IngestMode, ObjectDepth, OptionConnection, OptionDatabase, OptionStatement,
 };
 use adbc_core::schemas;
-use adbc_core::sync::{Connection, Database, Driver, Optionable, Statement};
+use adbc_core::{Connection, Database, Driver, Optionable, Statement};
 use adbc_driver_manager::{ManagedConnection, ManagedDatabase, ManagedDriver, ManagedStatement};
 
 use arrow_array::{
diff --git a/rust/driver_manager/tests/driver_manager_sqlite.rs b/rust/driver_manager/tests/driver_manager_sqlite.rs
index 3eb8c84eea..64a6da00bd 100644
--- a/rust/driver_manager/tests/driver_manager_sqlite.rs
+++ b/rust/driver_manager/tests/driver_manager_sqlite.rs
@@ -19,8 +19,8 @@ use arrow_schema::{Field, Schema};
 
 use adbc_core::error::Status;
 use adbc_core::options::{AdbcVersion, OptionConnection, OptionDatabase};
-use adbc_core::sync::{Connection, Database, Driver, Optionable, Statement};
 use adbc_core::LOAD_FLAG_DEFAULT;
+use adbc_core::{Connection, Database, Driver, Optionable, Statement};
 use adbc_driver_manager::{ManagedDatabase, ManagedDriver};
 
 mod common;
diff --git a/rust/ffi/src/driver_exporter.rs b/rust/ffi/src/driver_exporter.rs
index 0dca08b127..c142121bf1 100644
--- a/rust/ffi/src/driver_exporter.rs
+++ b/rust/ffi/src/driver_exporter.rs
@@ -32,7 +32,7 @@ use super::{
 use adbc_core::constants::ADBC_STATUS_OK;
 use adbc_core::error::{AdbcStatusCode, Error, Result, Status};
 use adbc_core::options::{InfoCode, ObjectDepth, OptionConnection, OptionDatabase, OptionValue};
-use adbc_core::sync::{Connection, Database, Driver, Optionable, Statement};
+use adbc_core::{Connection, Database, Driver, Optionable, Statement};
 
 type DatabaseType<DriverType> = <DriverType as Driver>::DatabaseType;
 type ConnectionType<DriverType> =
diff --git a/rust/ffi/src/lib.rs b/rust/ffi/src/lib.rs
index cc75191863..68ae30375b 100644
--- a/rust/ffi/src/lib.rs
+++ b/rust/ffi/src/lib.rs
@@ -34,7 +34,7 @@
 //!
 //! The driver exporter allows exposing native Rust drivers as C drivers to be
 //! used by other languages via their own driver manager. Once you have an
-//! implementation of [adbc_core::sync::Driver], provided that it also implements [Default], you
+//! implementation of [adbc_core::Driver], provided that it also implements [Default], you
 //! can build it as an object file implementing the C API with the
 //! [export_driver] macro.
 

From f0c6ae9bda2871932c0e2ddb5832420c4734b4e0 Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Fri, 5 Dec 2025 13:16:24 +0300
Subject: [PATCH 13/14] fix: docs

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/core/src/lib.rs     | 27 +++++++++++++++++++++------
 rust/core/src/options.rs | 14 +++++++-------
 rust/core/src/schemas.rs | 10 +++++-----
 3 files changed, 33 insertions(+), 18 deletions(-)

diff --git a/rust/core/src/lib.rs b/rust/core/src/lib.rs
index f53e5b4ecc..4cbf1aa61b 100644
--- a/rust/core/src/lib.rs
+++ b/rust/core/src/lib.rs
@@ -31,10 +31,25 @@
 //! # Native Rust drivers
 //!
 //! Native Rust drivers will implement the abstract API consisting of the traits:
-//! - [AsyncDriver]
-//! - [AsyncDatabase]
-//! - [AsyncConnection]
-//! - [AsyncStatement]
+//!
+//! - [Driver]
+//! - [Database]
+//! - [Connection]
+//! - [Statement]
+//!
+//! or async traits:
+//!
+//! - [crate::non_blocking::AsyncDriver]
+//! - [crate::non_blocking::AsyncDatabase]
+//! - [crate::non_blocking::AsyncConnection]
+//! - [crate::non_blocking::AsyncStatement]
+//!
+//! or async traits that doesn't require Send bound:
+//!
+//! - [crate::non_blocking::LocalAsyncDriver]
+//! - [crate::non_blocking::LocalAsyncDatabase]
+//! - [crate::non_blocking::LocalAsyncConnection]
+//! - [crate::non_blocking::LocalAsyncStatement]
 //!
 //! For drivers implemented in Rust, using these will be more efficient and
 //! safe, since it avoids the overhead of going through C FFI.
@@ -61,10 +76,10 @@ pub const LOAD_FLAG_DEFAULT: LoadFlags = LOAD_FLAG_SEARCH_ENV
     | LOAD_FLAG_ALLOW_RELATIVE_PATHS;
 
 /// Each data partition is described by an opaque byte array and can be
-/// retrieved with [AsyncConnection::read_partition].
+/// retrieved with [crate::Connection::read_partition].
 pub type Partitions = Vec<Vec<u8>>;
 
-/// A partitioned result set as returned by [AsyncStatement::execute_partitions].
+/// A partitioned result set as returned by [crate::Statement::execute_partitions].
 #[derive(Debug, PartialEq, Eq)]
 pub struct PartitionedResult {
     /// The result partitions.
diff --git a/rust/core/src/options.rs b/rust/core/src/options.rs
index dbf7f73e9c..91c0f06b7d 100644
--- a/rust/core/src/options.rs
+++ b/rust/core/src/options.rs
@@ -218,7 +218,7 @@ impl TryFrom<u32> for InfoCode {
     }
 }
 
-/// Depth parameter for [get_objects][crate::AsyncConnection::get_objects] method.
+/// Depth parameter for [get_objects][crate::Connection::get_objects] method.
 #[derive(Debug)]
 pub enum ObjectDepth {
     /// Catalogs, schemas, tables, and columns.
@@ -374,19 +374,19 @@ pub enum OptionStatement {
     Temporary,
     /// Whether query execution is nonblocking. By default, execution is blocking.
     ///
-    /// When enabled, [execute_partitions][crate::AsyncStatement::execute_partitions]
+    /// When enabled, [execute_partitions][crate::Statement::execute_partitions]
     /// will return partitions as soon as they are available, instead of returning
     /// them all at the end. When there are no more to return, it will return an
-    /// empty set of partitions. The methods [execute][crate::AsyncStatement::execute],
-    /// [execute_schema][crate::AsyncStatement::execute_schema] and
-    /// [execute_update][crate::AsyncStatement::execute_update] are not affected.
+    /// empty set of partitions. The methods [execute][crate::Statement::execute],
+    /// [execute_schema][crate::Statement::execute_schema] and
+    /// [execute_update][crate::Statement::execute_update] are not affected.
     ///
     /// # Since
     ///
     /// ADBC API revision 1.1.0
     Incremental,
     /// Get the progress of a query. It's a read-only option that should be
-    /// read with [get_option_double][crate::AsyncOptionable::get_option_double].
+    /// read with [get_option_double][crate::Optionable::get_option_double].
     ///
     /// The value is not necessarily in any particular range or have any
     /// particular units. For example, it might be a percentage, bytes of data,
@@ -400,7 +400,7 @@ pub enum OptionStatement {
     /// ADBC API revision 1.1.0
     Progress,
     /// Get the maximum progress of a query. It's a read-only option that should be
-    /// read with [get_option_double][crate::AsyncOptionable::get_option_double].
+    /// read with [get_option_double][crate::Optionable::get_option_double].
     ///
     /// This is the value of [OptionStatement::Progress] for a completed query.
     /// If not supported, or if the value is nonpositive, then the maximum is not
diff --git a/rust/core/src/schemas.rs b/rust/core/src/schemas.rs
index 4dfdc2dee6..156ee1aac6 100644
--- a/rust/core/src/schemas.rs
+++ b/rust/core/src/schemas.rs
@@ -21,7 +21,7 @@ use std::sync::{Arc, LazyLock};
 
 use arrow_schema::{DataType, Field, Schema, SchemaRef, UnionFields, UnionMode};
 
-/// Schema of the data returned by [get_table_types][crate::AsyncConnection::get_table_types].
+/// Schema of the data returned by [get_table_types][crate::Connection::get_table_types].
 pub static GET_TABLE_TYPES_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     Arc::new(Schema::new(vec![Field::new(
         "table_type",
@@ -30,7 +30,7 @@ pub static GET_TABLE_TYPES_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     )]))
 });
 
-/// Schema of the data returned by [get_info][crate::AsyncConnection::get_info].
+/// Schema of the data returned by [get_info][crate::Connection::get_info].
 pub static GET_INFO_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     let info_schema = DataType::Union(
         UnionFields::new(
@@ -64,7 +64,7 @@ pub static GET_INFO_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     ]))
 });
 
-/// Schema of data returned by [get_statistic_names][crate::AsyncConnection::get_statistic_names].
+/// Schema of data returned by [get_statistic_names][crate::Connection::get_statistic_names].
 pub static GET_STATISTIC_NAMES_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     Arc::new(Schema::new(vec![
         Field::new("statistic_name", DataType::Utf8, false),
@@ -114,7 +114,7 @@ pub static STATISTICS_DB_SCHEMA_SCHEMA: LazyLock<DataType> = LazyLock::new(|| {
     )
 });
 
-/// Schema of data returned by [get_statistics][crate::AsyncConnection::get_statistics].
+/// Schema of data returned by [get_statistics][crate::Connection::get_statistics].
 pub static GET_STATISTICS_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     Arc::new(Schema::new(vec![
         Field::new("catalog_name", DataType::Utf8, true),
@@ -219,7 +219,7 @@ pub static OBJECTS_DB_SCHEMA_SCHEMA: LazyLock<DataType> = LazyLock::new(|| {
     )
 });
 
-/// Schema of data returned by [get_objects][crate::AsyncConnection::get_objects].
+/// Schema of data returned by [get_objects][crate::Connection::get_objects].
 pub static GET_OBJECTS_SCHEMA: LazyLock<SchemaRef> = LazyLock::new(|| {
     Arc::new(Schema::new(vec![
         Field::new("catalog_name", DataType::Utf8, true),

From 49965550ab14610747d3a7aee5cd665552f5b05b Mon Sep 17 00:00:00 2001
From: if0ne <pavel.agafonov.al@gmail.com>
Date: Fri, 5 Dec 2025 13:23:48 +0300
Subject: [PATCH 14/14] changes: moved all sync wrappers into syncify module

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>
---
 rust/core/src/executor.rs         |  26 --
 rust/core/src/lib.rs              |   2 +-
 rust/core/src/sync.rs             | 410 +---------------------------
 rust/core/src/syncify.rs          | 439 ++++++++++++++++++++++++++++++
 rust/driver/datafusion/src/lib.rs |   4 +-
 5 files changed, 443 insertions(+), 438 deletions(-)
 delete mode 100644 rust/core/src/executor.rs
 create mode 100644 rust/core/src/syncify.rs

diff --git a/rust/core/src/executor.rs b/rust/core/src/executor.rs
deleted file mode 100644
index f04073d4ed..0000000000
--- a/rust/core/src/executor.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-use std::{fmt::Debug, future::Future};
-
-pub trait AsyncExecutor: Sized + Send + Sync {
-    type Config: Default;
-    type Error: Debug;
-
-    fn new(config: Self::Config) -> Result<Self, Self::Error>;
-    fn block_on<F: Future>(&self, future: F) -> F::Output;
-}
diff --git a/rust/core/src/lib.rs b/rust/core/src/lib.rs
index 4cbf1aa61b..36bbe10c46 100644
--- a/rust/core/src/lib.rs
+++ b/rust/core/src/lib.rs
@@ -56,11 +56,11 @@
 
 pub mod constants;
 pub mod error;
-pub mod executor;
 pub mod non_blocking;
 pub mod options;
 pub mod schemas;
 pub mod sync;
+pub mod syncify;
 
 pub use sync::*;
 
diff --git a/rust/core/src/sync.rs b/rust/core/src/sync.rs
index 061695616d..77b3fe3c2d 100644
--- a/rust/core/src/sync.rs
+++ b/rust/core/src/sync.rs
@@ -16,19 +16,11 @@
 // under the License.
 
 use std::collections::HashSet;
-use std::pin::Pin;
-use std::sync::Arc;
 
 use arrow_array::{RecordBatch, RecordBatchReader};
-use arrow_schema::{Schema, SchemaRef};
-use futures::StreamExt;
+use arrow_schema::Schema;
 
 use crate::error::Result;
-use crate::executor::AsyncExecutor;
-use crate::non_blocking::{
-    LocalAsyncConnection, LocalAsyncDatabase, LocalAsyncDriver, LocalAsyncOptionable,
-    LocalAsyncStatement,
-};
 use crate::options::{self, OptionConnection, OptionDatabase, OptionStatement, OptionValue};
 
 /// Ability to configure an object by setting/getting options.
@@ -472,403 +464,3 @@ pub trait Statement: Optionable<Option = OptionStatement> {
     /// ADBC API revision 1.1.0
     fn cancel(&mut self) -> Result<()>;
 }
-
-pub struct SyncRecordBatchStream<A> {
-    executor: Arc<A>,
-    inner: Pin<Box<dyn crate::non_blocking::RecordBatchStream + Send>>,
-}
-
-pub struct SyncDriverWrapper<A, D> {
-    inner: D,
-    executor: Arc<A>,
-}
-
-impl<A: AsyncExecutor> Iterator for SyncRecordBatchStream<A> {
-    type Item = std::result::Result<RecordBatch, arrow_schema::ArrowError>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.executor.block_on(self.inner.next())
-    }
-}
-
-impl<A: AsyncExecutor> RecordBatchReader for SyncRecordBatchStream<A> {
-    fn schema(&self) -> SchemaRef {
-        self.inner.schema()
-    }
-}
-
-pub struct WrapperRecordBatchReader {
-    inner: Box<dyn RecordBatchReader + Send>,
-}
-
-impl futures::Stream for WrapperRecordBatchReader {
-    type Item = std::result::Result<RecordBatch, arrow_schema::ArrowError>;
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        _cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Option<Self::Item>> {
-        std::task::Poll::Ready(self.get_mut().inner.next())
-    }
-}
-
-impl crate::non_blocking::RecordBatchStream for WrapperRecordBatchReader {
-    fn schema(&self) -> arrow_schema::SchemaRef {
-        self.inner.schema()
-    }
-}
-
-impl<A: AsyncExecutor, D: Default> Default for SyncDriverWrapper<A, D> {
-    fn default() -> Self {
-        Self {
-            inner: Default::default(),
-            executor: Arc::new(A::new(Default::default()).expect("failed to create executor")),
-        }
-    }
-}
-
-impl<A, D> Driver for SyncDriverWrapper<A, D>
-where
-    A: AsyncExecutor,
-    D: LocalAsyncDriver,
-    D::DatabaseType: LocalAsyncDatabase + LocalAsyncOptionable<Option = OptionDatabase>,
-    <D::DatabaseType as LocalAsyncDatabase>::ConnectionType:
-        LocalAsyncConnection + LocalAsyncOptionable<Option = OptionConnection>,
-    <<D::DatabaseType as LocalAsyncDatabase>::ConnectionType as LocalAsyncConnection>::StatementType: LocalAsyncOptionable<Option = OptionStatement>,
-{
-    type DatabaseType = SyncDatabaseWrapper<A, D::DatabaseType>;
-
-    fn new_database(&mut self) -> Result<Self::DatabaseType> {
-        let db = self.executor.block_on(self.inner.new_database())?;
-
-        Ok(SyncDatabaseWrapper { inner: db, executor: self.executor.clone() })
-    }
-
-    fn new_database_with_opts(
-        &mut self,
-        opts: impl IntoIterator<Item = (OptionDatabase, OptionValue)>,
-    ) -> Result<Self::DatabaseType> {
-        let db = self.executor.block_on(self.inner.new_database_with_opts(opts.into_iter().collect()))?;
-
-        Ok(SyncDatabaseWrapper { inner: db, executor: self.executor.clone() })
-    }
-}
-
-pub struct SyncDatabaseWrapper<A, DB> {
-    inner: DB,
-    executor: Arc<A>,
-}
-
-impl<A, DB> Optionable for SyncDatabaseWrapper<A, DB>
-where
-    A: AsyncExecutor,
-    DB: LocalAsyncOptionable<Option = OptionDatabase>,
-{
-    type Option = OptionDatabase;
-
-    fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()> {
-        self.executor.block_on(self.inner.set_option(key, value))
-    }
-
-    fn get_option_string(&self, key: Self::Option) -> Result<String> {
-        self.executor.block_on(self.inner.get_option_string(key))
-    }
-
-    fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>> {
-        self.executor.block_on(self.inner.get_option_bytes(key))
-    }
-
-    fn get_option_int(&self, key: Self::Option) -> Result<i64> {
-        self.executor.block_on(self.inner.get_option_int(key))
-    }
-
-    fn get_option_double(&self, key: Self::Option) -> Result<f64> {
-        self.executor.block_on(self.inner.get_option_double(key))
-    }
-}
-
-impl<A, DB> Database for SyncDatabaseWrapper<A, DB>
-where
-    A: AsyncExecutor,
-    DB: LocalAsyncDatabase + LocalAsyncOptionable<Option = OptionDatabase>,
-    DB::ConnectionType: LocalAsyncConnection + LocalAsyncOptionable<Option = OptionConnection>,
-    <DB::ConnectionType as LocalAsyncConnection>::StatementType:
-        LocalAsyncOptionable<Option = OptionStatement>,
-{
-    type ConnectionType = SyncConnectionWrapper<A, DB::ConnectionType>;
-
-    fn new_connection(&self) -> Result<Self::ConnectionType> {
-        let conn = self.executor.block_on(self.inner.new_connection())?;
-
-        Ok(SyncConnectionWrapper {
-            inner: conn,
-            executor: self.executor.clone(),
-        })
-    }
-
-    fn new_connection_with_opts(
-        &self,
-        opts: impl IntoIterator<Item = (options::OptionConnection, OptionValue)>,
-    ) -> Result<Self::ConnectionType> {
-        let conn = self.executor.block_on(
-            self.inner
-                .new_connection_with_opts(opts.into_iter().collect()),
-        )?;
-
-        Ok(SyncConnectionWrapper {
-            inner: conn,
-            executor: self.executor.clone(),
-        })
-    }
-}
-
-pub struct SyncConnectionWrapper<A, Conn> {
-    inner: Conn,
-    executor: Arc<A>,
-}
-
-impl<A, Conn> Optionable for SyncConnectionWrapper<A, Conn>
-where
-    A: AsyncExecutor,
-    Conn: LocalAsyncOptionable<Option = OptionConnection>,
-{
-    type Option = OptionConnection;
-
-    fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()> {
-        self.executor.block_on(self.inner.set_option(key, value))
-    }
-
-    fn get_option_string(&self, key: Self::Option) -> Result<String> {
-        self.executor.block_on(self.inner.get_option_string(key))
-    }
-
-    fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>> {
-        self.executor.block_on(self.inner.get_option_bytes(key))
-    }
-
-    fn get_option_int(&self, key: Self::Option) -> Result<i64> {
-        self.executor.block_on(self.inner.get_option_int(key))
-    }
-
-    fn get_option_double(&self, key: Self::Option) -> Result<f64> {
-        self.executor.block_on(self.inner.get_option_double(key))
-    }
-}
-
-impl<A, Conn> Connection for SyncConnectionWrapper<A, Conn>
-where
-    A: AsyncExecutor,
-    Conn: LocalAsyncConnection + LocalAsyncOptionable<Option = OptionConnection>,
-    Conn::StatementType: LocalAsyncOptionable<Option = OptionStatement>,
-{
-    type StatementType = SyncStatementWrapper<A, Conn::StatementType>;
-
-    fn new_statement(&mut self) -> Result<Self::StatementType> {
-        let stmt = self.executor.block_on(self.inner.new_statement())?;
-
-        Ok(SyncStatementWrapper {
-            inner: stmt,
-            executor: self.executor.clone(),
-        })
-    }
-
-    fn cancel(&mut self) -> Result<()> {
-        self.executor.block_on(self.inner.cancel())
-    }
-
-    fn get_info(
-        &self,
-        codes: Option<HashSet<options::InfoCode>>,
-    ) -> Result<impl RecordBatchReader + Send> {
-        let reader = self.executor.block_on(self.inner.get_info(codes))?;
-
-        Ok(SyncRecordBatchStream {
-            executor: self.executor.clone(),
-            inner: reader,
-        })
-    }
-
-    fn get_objects(
-        &self,
-        depth: options::ObjectDepth,
-        catalog: Option<&str>,
-        db_schema: Option<&str>,
-        table_name: Option<&str>,
-        table_type: Option<Vec<&str>>,
-        column_name: Option<&str>,
-    ) -> Result<impl RecordBatchReader + Send> {
-        let reader = self.executor.block_on(self.inner.get_objects(
-            depth,
-            catalog,
-            db_schema,
-            table_name,
-            table_type,
-            column_name,
-        ))?;
-
-        Ok(SyncRecordBatchStream {
-            executor: self.executor.clone(),
-            inner: reader,
-        })
-    }
-
-    fn get_table_schema(
-        &self,
-        catalog: Option<&str>,
-        db_schema: Option<&str>,
-        table_name: &str,
-    ) -> Result<Schema> {
-        self.executor
-            .block_on(self.inner.get_table_schema(catalog, db_schema, table_name))
-    }
-
-    fn get_table_types(&self) -> Result<impl RecordBatchReader + Send> {
-        let reader = self.executor.block_on(self.inner.get_table_types())?;
-
-        Ok(SyncRecordBatchStream {
-            executor: self.executor.clone(),
-            inner: reader,
-        })
-    }
-
-    fn get_statistic_names(&self) -> Result<impl RecordBatchReader + Send> {
-        let reader = self.executor.block_on(self.inner.get_statistic_names())?;
-
-        Ok(SyncRecordBatchStream {
-            executor: self.executor.clone(),
-            inner: reader,
-        })
-    }
-
-    fn get_statistics(
-        &self,
-        catalog: Option<&str>,
-        db_schema: Option<&str>,
-        table_name: Option<&str>,
-        approximate: bool,
-    ) -> Result<impl RecordBatchReader + Send> {
-        let reader = self.executor.block_on(self.inner.get_statistics(
-            catalog,
-            db_schema,
-            table_name,
-            approximate,
-        ))?;
-
-        Ok(SyncRecordBatchStream {
-            executor: self.executor.clone(),
-            inner: reader,
-        })
-    }
-
-    fn commit(&mut self) -> Result<()> {
-        self.executor.block_on(self.inner.commit())
-    }
-
-    fn rollback(&mut self) -> Result<()> {
-        self.executor.block_on(self.inner.rollback())
-    }
-
-    fn read_partition(&self, partition: &[u8]) -> Result<impl RecordBatchReader + Send> {
-        let reader = self
-            .executor
-            .block_on(self.inner.read_partition(partition))?;
-
-        Ok(SyncRecordBatchStream {
-            executor: self.executor.clone(),
-            inner: reader,
-        })
-    }
-}
-
-pub struct SyncStatementWrapper<A, T> {
-    inner: T,
-    executor: Arc<A>,
-}
-
-impl<A, Stmt> Optionable for SyncStatementWrapper<A, Stmt>
-where
-    A: AsyncExecutor,
-    Stmt: LocalAsyncOptionable<Option = OptionStatement>,
-{
-    type Option = OptionStatement;
-
-    fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()> {
-        self.executor.block_on(self.inner.set_option(key, value))
-    }
-
-    fn get_option_string(&self, key: Self::Option) -> Result<String> {
-        self.executor.block_on(self.inner.get_option_string(key))
-    }
-
-    fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>> {
-        self.executor.block_on(self.inner.get_option_bytes(key))
-    }
-
-    fn get_option_int(&self, key: Self::Option) -> Result<i64> {
-        self.executor.block_on(self.inner.get_option_int(key))
-    }
-
-    fn get_option_double(&self, key: Self::Option) -> Result<f64> {
-        self.executor.block_on(self.inner.get_option_double(key))
-    }
-}
-
-impl<A, Stmt> Statement for SyncStatementWrapper<A, Stmt>
-where
-    A: AsyncExecutor,
-    Stmt: LocalAsyncStatement + LocalAsyncOptionable<Option = OptionStatement>,
-{
-    fn bind(&mut self, batch: RecordBatch) -> Result<()> {
-        self.executor.block_on(self.inner.bind(batch))
-    }
-
-    fn bind_stream(&mut self, reader: Box<dyn RecordBatchReader + Send>) -> Result<()> {
-        self.executor.block_on(
-            self.inner
-                .bind_stream(Box::pin(WrapperRecordBatchReader { inner: reader })),
-        )
-    }
-
-    fn execute(&mut self) -> Result<impl RecordBatchReader + Send> {
-        let reader = self.executor.block_on(self.inner.execute())?;
-
-        Ok(SyncRecordBatchStream {
-            executor: self.executor.clone(),
-            inner: reader,
-        })
-    }
-
-    fn execute_update(&mut self) -> Result<Option<i64>> {
-        self.executor.block_on(self.inner.execute_update())
-    }
-
-    fn execute_schema(&mut self) -> Result<Schema> {
-        self.executor.block_on(self.inner.execute_schema())
-    }
-
-    fn execute_partitions(&mut self) -> Result<crate::PartitionedResult> {
-        self.executor.block_on(self.inner.execute_partitions())
-    }
-
-    fn get_parameter_schema(&self) -> Result<Schema> {
-        self.executor.block_on(self.inner.get_parameter_schema())
-    }
-
-    fn prepare(&mut self) -> Result<()> {
-        self.executor.block_on(self.inner.prepare())
-    }
-
-    fn set_sql_query(&mut self, query: impl AsRef<str>) -> Result<()> {
-        self.executor
-            .block_on(self.inner.set_sql_query(query.as_ref()))
-    }
-
-    fn set_substrait_plan(&mut self, plan: impl AsRef<[u8]>) -> Result<()> {
-        self.executor
-            .block_on(self.inner.set_substrait_plan(plan.as_ref()))
-    }
-
-    fn cancel(&mut self) -> Result<()> {
-        self.executor.block_on(self.inner.cancel())
-    }
-}
diff --git a/rust/core/src/syncify.rs b/rust/core/src/syncify.rs
new file mode 100644
index 0000000000..45236a7fb1
--- /dev/null
+++ b/rust/core/src/syncify.rs
@@ -0,0 +1,439 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::{collections::HashSet, fmt::Debug, future::Future, pin::Pin, sync::Arc};
+
+use arrow_array::{RecordBatch, RecordBatchReader};
+use arrow_schema::{Schema, SchemaRef};
+use futures::StreamExt;
+
+use crate::{
+    error::Result,
+    non_blocking::{
+        LocalAsyncConnection, LocalAsyncDatabase, LocalAsyncDriver, LocalAsyncOptionable,
+        LocalAsyncStatement,
+    },
+    options::{
+        InfoCode, ObjectDepth, OptionConnection, OptionDatabase, OptionStatement, OptionValue,
+    },
+    Connection, Database, Driver, Optionable, Statement,
+};
+
+pub trait AsyncExecutor: Sized + Send + Sync {
+    type Config: Default;
+    type Error: Debug;
+
+    fn new(config: Self::Config) -> std::result::Result<Self, Self::Error>;
+    fn block_on<F: Future>(&self, future: F) -> F::Output;
+}
+
+pub struct SyncRecordBatchStream<A> {
+    executor: Arc<A>,
+    inner: Pin<Box<dyn crate::non_blocking::RecordBatchStream + Send>>,
+}
+
+pub struct SyncDriverWrapper<A, D> {
+    inner: D,
+    executor: Arc<A>,
+}
+
+impl<A: AsyncExecutor> Iterator for SyncRecordBatchStream<A> {
+    type Item = std::result::Result<RecordBatch, arrow_schema::ArrowError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.executor.block_on(self.inner.next())
+    }
+}
+
+impl<A: AsyncExecutor> RecordBatchReader for SyncRecordBatchStream<A> {
+    fn schema(&self) -> SchemaRef {
+        self.inner.schema()
+    }
+}
+
+pub struct WrapperRecordBatchReader {
+    inner: Box<dyn RecordBatchReader + Send>,
+}
+
+impl futures::Stream for WrapperRecordBatchReader {
+    type Item = std::result::Result<RecordBatch, arrow_schema::ArrowError>;
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        std::task::Poll::Ready(self.get_mut().inner.next())
+    }
+}
+
+impl crate::non_blocking::RecordBatchStream for WrapperRecordBatchReader {
+    fn schema(&self) -> arrow_schema::SchemaRef {
+        self.inner.schema()
+    }
+}
+
+impl<A: AsyncExecutor, D: Default> Default for SyncDriverWrapper<A, D> {
+    fn default() -> Self {
+        Self {
+            inner: Default::default(),
+            executor: Arc::new(A::new(Default::default()).expect("failed to create executor")),
+        }
+    }
+}
+
+impl<A, D> Driver for SyncDriverWrapper<A, D>
+where
+    A: AsyncExecutor,
+    D: LocalAsyncDriver,
+    D::DatabaseType: LocalAsyncDatabase + LocalAsyncOptionable<Option = OptionDatabase>,
+    <D::DatabaseType as LocalAsyncDatabase>::ConnectionType:
+        LocalAsyncConnection + LocalAsyncOptionable<Option = OptionConnection>,
+    <<D::DatabaseType as LocalAsyncDatabase>::ConnectionType as LocalAsyncConnection>::StatementType: LocalAsyncOptionable<Option = OptionStatement>,
+{
+    type DatabaseType = SyncDatabaseWrapper<A, D::DatabaseType>;
+
+    fn new_database(&mut self) -> Result<Self::DatabaseType> {
+        let db = self.executor.block_on(self.inner.new_database())?;
+
+        Ok(SyncDatabaseWrapper { inner: db, executor: self.executor.clone() })
+    }
+
+    fn new_database_with_opts(
+        &mut self,
+        opts: impl IntoIterator<Item = (OptionDatabase, OptionValue)>,
+    ) -> Result<Self::DatabaseType> {
+        let db = self.executor.block_on(self.inner.new_database_with_opts(opts.into_iter().collect()))?;
+
+        Ok(SyncDatabaseWrapper { inner: db, executor: self.executor.clone() })
+    }
+}
+
+pub struct SyncDatabaseWrapper<A, DB> {
+    inner: DB,
+    executor: Arc<A>,
+}
+
+impl<A, DB> Optionable for SyncDatabaseWrapper<A, DB>
+where
+    A: AsyncExecutor,
+    DB: LocalAsyncOptionable<Option = OptionDatabase>,
+{
+    type Option = OptionDatabase;
+
+    fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()> {
+        self.executor.block_on(self.inner.set_option(key, value))
+    }
+
+    fn get_option_string(&self, key: Self::Option) -> Result<String> {
+        self.executor.block_on(self.inner.get_option_string(key))
+    }
+
+    fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>> {
+        self.executor.block_on(self.inner.get_option_bytes(key))
+    }
+
+    fn get_option_int(&self, key: Self::Option) -> Result<i64> {
+        self.executor.block_on(self.inner.get_option_int(key))
+    }
+
+    fn get_option_double(&self, key: Self::Option) -> Result<f64> {
+        self.executor.block_on(self.inner.get_option_double(key))
+    }
+}
+
+impl<A, DB> Database for SyncDatabaseWrapper<A, DB>
+where
+    A: AsyncExecutor,
+    DB: LocalAsyncDatabase + LocalAsyncOptionable<Option = OptionDatabase>,
+    DB::ConnectionType: LocalAsyncConnection + LocalAsyncOptionable<Option = OptionConnection>,
+    <DB::ConnectionType as LocalAsyncConnection>::StatementType:
+        LocalAsyncOptionable<Option = OptionStatement>,
+{
+    type ConnectionType = SyncConnectionWrapper<A, DB::ConnectionType>;
+
+    fn new_connection(&self) -> Result<Self::ConnectionType> {
+        let conn = self.executor.block_on(self.inner.new_connection())?;
+
+        Ok(SyncConnectionWrapper {
+            inner: conn,
+            executor: self.executor.clone(),
+        })
+    }
+
+    fn new_connection_with_opts(
+        &self,
+        opts: impl IntoIterator<Item = (OptionConnection, OptionValue)>,
+    ) -> Result<Self::ConnectionType> {
+        let conn = self.executor.block_on(
+            self.inner
+                .new_connection_with_opts(opts.into_iter().collect()),
+        )?;
+
+        Ok(SyncConnectionWrapper {
+            inner: conn,
+            executor: self.executor.clone(),
+        })
+    }
+}
+
+pub struct SyncConnectionWrapper<A, Conn> {
+    inner: Conn,
+    executor: Arc<A>,
+}
+
+impl<A, Conn> Optionable for SyncConnectionWrapper<A, Conn>
+where
+    A: AsyncExecutor,
+    Conn: LocalAsyncOptionable<Option = OptionConnection>,
+{
+    type Option = OptionConnection;
+
+    fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()> {
+        self.executor.block_on(self.inner.set_option(key, value))
+    }
+
+    fn get_option_string(&self, key: Self::Option) -> Result<String> {
+        self.executor.block_on(self.inner.get_option_string(key))
+    }
+
+    fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>> {
+        self.executor.block_on(self.inner.get_option_bytes(key))
+    }
+
+    fn get_option_int(&self, key: Self::Option) -> Result<i64> {
+        self.executor.block_on(self.inner.get_option_int(key))
+    }
+
+    fn get_option_double(&self, key: Self::Option) -> Result<f64> {
+        self.executor.block_on(self.inner.get_option_double(key))
+    }
+}
+
+impl<A, Conn> Connection for SyncConnectionWrapper<A, Conn>
+where
+    A: AsyncExecutor,
+    Conn: LocalAsyncConnection + LocalAsyncOptionable<Option = OptionConnection>,
+    Conn::StatementType: LocalAsyncOptionable<Option = OptionStatement>,
+{
+    type StatementType = SyncStatementWrapper<A, Conn::StatementType>;
+
+    fn new_statement(&mut self) -> Result<Self::StatementType> {
+        let stmt = self.executor.block_on(self.inner.new_statement())?;
+
+        Ok(SyncStatementWrapper {
+            inner: stmt,
+            executor: self.executor.clone(),
+        })
+    }
+
+    fn cancel(&mut self) -> Result<()> {
+        self.executor.block_on(self.inner.cancel())
+    }
+
+    fn get_info(&self, codes: Option<HashSet<InfoCode>>) -> Result<impl RecordBatchReader + Send> {
+        let reader = self.executor.block_on(self.inner.get_info(codes))?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
+    }
+
+    fn get_objects(
+        &self,
+        depth: ObjectDepth,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        table_type: Option<Vec<&str>>,
+        column_name: Option<&str>,
+    ) -> Result<impl RecordBatchReader + Send> {
+        let reader = self.executor.block_on(self.inner.get_objects(
+            depth,
+            catalog,
+            db_schema,
+            table_name,
+            table_type,
+            column_name,
+        ))?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
+    }
+
+    fn get_table_schema(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: &str,
+    ) -> Result<Schema> {
+        self.executor
+            .block_on(self.inner.get_table_schema(catalog, db_schema, table_name))
+    }
+
+    fn get_table_types(&self) -> Result<impl RecordBatchReader + Send> {
+        let reader = self.executor.block_on(self.inner.get_table_types())?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
+    }
+
+    fn get_statistic_names(&self) -> Result<impl RecordBatchReader + Send> {
+        let reader = self.executor.block_on(self.inner.get_statistic_names())?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
+    }
+
+    fn get_statistics(
+        &self,
+        catalog: Option<&str>,
+        db_schema: Option<&str>,
+        table_name: Option<&str>,
+        approximate: bool,
+    ) -> Result<impl RecordBatchReader + Send> {
+        let reader = self.executor.block_on(self.inner.get_statistics(
+            catalog,
+            db_schema,
+            table_name,
+            approximate,
+        ))?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
+    }
+
+    fn commit(&mut self) -> Result<()> {
+        self.executor.block_on(self.inner.commit())
+    }
+
+    fn rollback(&mut self) -> Result<()> {
+        self.executor.block_on(self.inner.rollback())
+    }
+
+    fn read_partition(&self, partition: &[u8]) -> Result<impl RecordBatchReader + Send> {
+        let reader = self
+            .executor
+            .block_on(self.inner.read_partition(partition))?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
+    }
+}
+
+pub struct SyncStatementWrapper<A, T> {
+    inner: T,
+    executor: Arc<A>,
+}
+
+impl<A, Stmt> Optionable for SyncStatementWrapper<A, Stmt>
+where
+    A: AsyncExecutor,
+    Stmt: LocalAsyncOptionable<Option = OptionStatement>,
+{
+    type Option = OptionStatement;
+
+    fn set_option(&mut self, key: Self::Option, value: OptionValue) -> Result<()> {
+        self.executor.block_on(self.inner.set_option(key, value))
+    }
+
+    fn get_option_string(&self, key: Self::Option) -> Result<String> {
+        self.executor.block_on(self.inner.get_option_string(key))
+    }
+
+    fn get_option_bytes(&self, key: Self::Option) -> Result<Vec<u8>> {
+        self.executor.block_on(self.inner.get_option_bytes(key))
+    }
+
+    fn get_option_int(&self, key: Self::Option) -> Result<i64> {
+        self.executor.block_on(self.inner.get_option_int(key))
+    }
+
+    fn get_option_double(&self, key: Self::Option) -> Result<f64> {
+        self.executor.block_on(self.inner.get_option_double(key))
+    }
+}
+
+impl<A, Stmt> Statement for SyncStatementWrapper<A, Stmt>
+where
+    A: AsyncExecutor,
+    Stmt: LocalAsyncStatement + LocalAsyncOptionable<Option = OptionStatement>,
+{
+    fn bind(&mut self, batch: RecordBatch) -> Result<()> {
+        self.executor.block_on(self.inner.bind(batch))
+    }
+
+    fn bind_stream(&mut self, reader: Box<dyn RecordBatchReader + Send>) -> Result<()> {
+        self.executor.block_on(
+            self.inner
+                .bind_stream(Box::pin(WrapperRecordBatchReader { inner: reader })),
+        )
+    }
+
+    fn execute(&mut self) -> Result<impl RecordBatchReader + Send> {
+        let reader = self.executor.block_on(self.inner.execute())?;
+
+        Ok(SyncRecordBatchStream {
+            executor: self.executor.clone(),
+            inner: reader,
+        })
+    }
+
+    fn execute_update(&mut self) -> Result<Option<i64>> {
+        self.executor.block_on(self.inner.execute_update())
+    }
+
+    fn execute_schema(&mut self) -> Result<Schema> {
+        self.executor.block_on(self.inner.execute_schema())
+    }
+
+    fn execute_partitions(&mut self) -> Result<crate::PartitionedResult> {
+        self.executor.block_on(self.inner.execute_partitions())
+    }
+
+    fn get_parameter_schema(&self) -> Result<Schema> {
+        self.executor.block_on(self.inner.get_parameter_schema())
+    }
+
+    fn prepare(&mut self) -> Result<()> {
+        self.executor.block_on(self.inner.prepare())
+    }
+
+    fn set_sql_query(&mut self, query: impl AsRef<str>) -> Result<()> {
+        self.executor
+            .block_on(self.inner.set_sql_query(query.as_ref()))
+    }
+
+    fn set_substrait_plan(&mut self, plan: impl AsRef<[u8]>) -> Result<()> {
+        self.executor
+            .block_on(self.inner.set_substrait_plan(plan.as_ref()))
+    }
+
+    fn cancel(&mut self) -> Result<()> {
+        self.executor.block_on(self.inner.cancel())
+    }
+}
diff --git a/rust/driver/datafusion/src/lib.rs b/rust/driver/datafusion/src/lib.rs
index 68d58b3964..0010970ceb 100644
--- a/rust/driver/datafusion/src/lib.rs
+++ b/rust/driver/datafusion/src/lib.rs
@@ -16,8 +16,8 @@
 // under the License.
 #![allow(refining_impl_trait)]
 
-use adbc_core::executor::AsyncExecutor;
 use adbc_core::non_blocking::{AsyncConnection, AsyncDatabase, AsyncDriver, AsyncStatement};
+use adbc_core::syncify::AsyncExecutor;
 use adbc_core::{
     constants,
     non_blocking::{AsyncOptionable, RecordBatchStream},
@@ -986,5 +986,5 @@ impl AsyncExecutor for TokioRuntime {
 #[cfg(feature = "ffi")]
 adbc_ffi::export_driver!(
     DataFusionDriverInit,
-    adbc_core::SyncDriverWrapper::<TokioRuntime, DataFusionDriver>
+    adbc_core::syncify::SyncDriverWrapper::<TokioRuntime, DataFusionDriver>
 );