You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by pa...@apache.org on 2023/11/09 13:48:50 UTC

(arrow-adbc) branch main updated: refactor(r/adbcdrivermanager): Use C++ base driver to implement test drivers (#1269)

This is an automated email from the ASF dual-hosted git repository.

paleolimbot pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-adbc.git


The following commit(s) were added to refs/heads/main by this push:
     new bf4bd1b7 refactor(r/adbcdrivermanager): Use C++ base driver to implement test drivers (#1269)
bf4bd1b7 is described below

commit bf4bd1b71e676ed82a73480396df3b8a5c17968c
Author: Dewey Dunnington <de...@voltrondata.com>
AuthorDate: Thu Nov 9 09:48:45 2023 -0400

    refactor(r/adbcdrivermanager): Use C++ base driver to implement test drivers (#1269)
    
    Now that there is a driver helper, we can simplify the implementation of
    two more test drivers. This required adding the rest of the methods to
    the driver helper as well. I also
    
    - Added `adbc_statement_cancel()`, which I'd missed in a previous PR
    - Fixed error handling for several methods, from which errors had been
    being ignored
    - Improved testing of the log driver, which only had coverage on a few
    of its methods
    - Fixed errors in get_option tests that were spotted when verifying C++
    code coverage of the driver helper
---
 r/adbcdrivermanager/NAMESPACE                      |   1 +
 r/adbcdrivermanager/R/adbc.R                       |  18 +-
 .../man/adbc_statement_set_sql_query.Rd            |   3 +
 r/adbcdrivermanager/src/driver_base.h              | 220 ++++++++++++-
 r/adbcdrivermanager/src/driver_log.c               | 343 ---------------------
 r/adbcdrivermanager/src/driver_monkey.c            | 342 --------------------
 r/adbcdrivermanager/src/driver_test.cc             | 283 +++++++++++++++++
 r/adbcdrivermanager/src/driver_void.cc             |  41 ---
 r/adbcdrivermanager/src/init.c                     |  10 +-
 r/adbcdrivermanager/src/radbc.cc                   |   7 +
 .../tests/testthat/_snaps/driver_log.md            | 103 ++++++-
 .../tests/testthat/_snaps/helpers.md               |   3 -
 .../tests/testthat/test-driver_log.R               |  24 ++
 .../tests/testthat/test-driver_monkey.R            |   2 +-
 r/adbcdrivermanager/tests/testthat/test-options.R  |  18 +-
 r/adbcdrivermanager/tests/testthat/test-radbc.R    |  17 +-
 16 files changed, 672 insertions(+), 763 deletions(-)

diff --git a/r/adbcdrivermanager/NAMESPACE b/r/adbcdrivermanager/NAMESPACE
index 74ba9797..894851a0 100644
--- a/r/adbcdrivermanager/NAMESPACE
+++ b/r/adbcdrivermanager/NAMESPACE
@@ -67,6 +67,7 @@ export(adbc_driver_void)
 export(adbc_error_from_array_stream)
 export(adbc_statement_bind)
 export(adbc_statement_bind_stream)
+export(adbc_statement_cancel)
 export(adbc_statement_execute_query)
 export(adbc_statement_execute_schema)
 export(adbc_statement_get_option)
diff --git a/r/adbcdrivermanager/R/adbc.R b/r/adbcdrivermanager/R/adbc.R
index 8a333465..60e271d9 100644
--- a/r/adbcdrivermanager/R/adbc.R
+++ b/r/adbcdrivermanager/R/adbc.R
@@ -265,7 +265,8 @@ adbc_connection_read_partition <- function(connection, serialized_partition) {
 #' @export
 adbc_connection_commit <- function(connection) {
   error <- adbc_allocate_error()
-  .Call(RAdbcConnectionCommit, connection, error)
+  status <- .Call(RAdbcConnectionCommit, connection, error)
+  stop_for_error(status, error)
   invisible(connection)
 }
 
@@ -274,7 +275,8 @@ adbc_connection_commit <- function(connection) {
 #' @export
 adbc_connection_rollback <- function(connection) {
   error <- adbc_allocate_error()
-  .Call(RAdbcConnectionRollback, connection, error)
+  status <- .Call(RAdbcConnectionRollback, connection, error)
+  stop_for_error(status, error)
   invisible(connection)
 }
 
@@ -282,7 +284,8 @@ adbc_connection_rollback <- function(connection) {
 #' @export
 adbc_connection_cancel <- function(connection) {
   error <- adbc_allocate_error()
-  .Call(RAdbcConnectionCancel, connection, error)
+  status <- .Call(RAdbcConnectionCancel, connection, error)
+  stop_for_error(status, error)
   invisible(connection)
 }
 
@@ -498,3 +501,12 @@ adbc_statement_execute_schema <- function(statement) {
 
   out_schema
 }
+
+#' @rdname adbc_statement_set_sql_query
+#' @export
+adbc_statement_cancel <- function(statement) {
+  error <- adbc_allocate_error()
+  status <- .Call(RAdbcStatementCancel, statement, error)
+  stop_for_error(status, error)
+  invisible(statement)
+}
diff --git a/r/adbcdrivermanager/man/adbc_statement_set_sql_query.Rd b/r/adbcdrivermanager/man/adbc_statement_set_sql_query.Rd
index ea955ddb..f83f61c7 100644
--- a/r/adbcdrivermanager/man/adbc_statement_set_sql_query.Rd
+++ b/r/adbcdrivermanager/man/adbc_statement_set_sql_query.Rd
@@ -9,6 +9,7 @@
 \alias{adbc_statement_bind_stream}
 \alias{adbc_statement_execute_query}
 \alias{adbc_statement_execute_schema}
+\alias{adbc_statement_cancel}
 \title{Statement methods}
 \usage{
 adbc_statement_set_sql_query(statement, query)
@@ -26,6 +27,8 @@ adbc_statement_bind_stream(statement, stream, schema = NULL)
 adbc_statement_execute_query(statement, stream = NULL)
 
 adbc_statement_execute_schema(statement)
+
+adbc_statement_cancel(statement)
 }
 \arguments{
 \item{statement}{An \link[=adbc_statement_init]{adbc_statement}}
diff --git a/r/adbcdrivermanager/src/driver_base.h b/r/adbcdrivermanager/src/driver_base.h
index 9eb1ff90..5a4f65f1 100644
--- a/r/adbcdrivermanager/src/driver_base.h
+++ b/r/adbcdrivermanager/src/driver_base.h
@@ -231,8 +231,8 @@ class ObjectBase {
   virtual AdbcStatusCode Release(AdbcError* error) { return ADBC_STATUS_OK; }
 
   // Get an option that was previously set, providing an optional default value.
-  const Option& GetOption(const std::string& key,
-                          const Option& default_value = Option()) const {
+  virtual const Option& GetOption(const std::string& key,
+                                  const Option& default_value = Option()) const {
     auto result = options_.find(key);
     if (result == options_.end()) {
       return default_value;
@@ -337,7 +337,51 @@ class DatabaseObjectBase : public ObjectBase {
 // implement the corresponding ConnectionXXX driver methods.
 class ConnectionObjectBase : public ObjectBase {
  public:
-  // TODO: Add connection functions here as methods
+  virtual AdbcStatusCode Commit(AdbcError* error) { return ADBC_STATUS_NOT_IMPLEMENTED; }
+
+  virtual AdbcStatusCode GetInfo(const uint32_t* info_codes, size_t info_codes_length,
+                                 ArrowArrayStream* out, AdbcError* error) {
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  virtual AdbcStatusCode GetObjects(int depth, const char* catalog, const char* db_schema,
+                                    const char* table_name, const char** table_type,
+                                    const char* column_name, ArrowArrayStream* out,
+                                    AdbcError* error) {
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  virtual AdbcStatusCode GetTableSchema(const char* catalog, const char* db_schema,
+                                        const char* table_name, ArrowSchema* schema,
+                                        AdbcError* error) {
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  virtual AdbcStatusCode GetTableTypes(ArrowArrayStream* out, AdbcError* error) {
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  virtual AdbcStatusCode ReadPartition(const uint8_t* serialized_partition,
+                                       size_t serialized_length, ArrowArrayStream* out,
+                                       AdbcError* error) {
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  virtual AdbcStatusCode Rollback(AdbcError* error) {
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  virtual AdbcStatusCode Cancel(AdbcError* error) { return ADBC_STATUS_NOT_IMPLEMENTED; }
+
+  virtual AdbcStatusCode GetStatistics(const char* catalog, const char* db_schema,
+                                       const char* table_name, char approximate,
+                                       ArrowArrayStream* out, AdbcError* error) {
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  virtual AdbcStatusCode GetStatisticNames(ArrowArrayStream* out, AdbcError* error) {
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
 };
 
 // Driver authors can subclass StatementObjectBase to track driver-specific
@@ -347,12 +391,35 @@ class ConnectionObjectBase : public ObjectBase {
 // implement the corresponding StatementXXX driver methods.
 class StatementObjectBase : public ObjectBase {
  public:
-  virtual AdbcStatusCode ExecuteQuery(struct ArrowArrayStream* stream,
-                                      int64_t* rows_affected, struct AdbcError* error) {
+  virtual AdbcStatusCode ExecuteQuery(ArrowArrayStream* stream, int64_t* rows_affected,
+                                      AdbcError* error) {
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  virtual AdbcStatusCode ExecuteSchema(ArrowSchema* schema, AdbcError* error) {
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  virtual AdbcStatusCode Prepare(AdbcError* error) { return ADBC_STATUS_NOT_IMPLEMENTED; }
+
+  virtual AdbcStatusCode SetSqlQuery(const char* query, AdbcError* error) {
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  virtual AdbcStatusCode SetSubstraitPlan(const uint8_t* plan, size_t length,
+                                          AdbcError* error) {
     return ADBC_STATUS_NOT_IMPLEMENTED;
   }
 
-  // TODO: Add remaining statement functions here as methods
+  virtual AdbcStatusCode Bind(ArrowArray* values, ArrowSchema* schema, AdbcError* error) {
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  virtual AdbcStatusCode BindStream(ArrowArrayStream* stream, AdbcError* error) {
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  virtual AdbcStatusCode Cancel(AdbcError* error) { return ADBC_STATUS_NOT_IMPLEMENTED; }
 };
 
 // Driver authors can declare a template specialization of the Driver class
@@ -363,7 +430,7 @@ class Driver {
  public:
   static AdbcStatusCode Init(int version, void* raw_driver, AdbcError* error) {
     if (version != ADBC_VERSION_1_1_0) return ADBC_STATUS_NOT_IMPLEMENTED;
-    struct AdbcDriver* driver = (AdbcDriver*)raw_driver;
+    AdbcDriver* driver = (AdbcDriver*)raw_driver;
     std::memset(driver, 0, sizeof(AdbcDriver));
 
     // Driver lifecycle
@@ -403,6 +470,16 @@ class Driver {
     driver->ConnectionGetOptionBytes = &CGetOptionBytes<AdbcConnection, ConnectionT>;
     driver->ConnectionGetOptionInt = &CGetOptionInt<AdbcConnection, ConnectionT>;
     driver->ConnectionGetOptionDouble = &CGetOptionDouble<AdbcConnection, ConnectionT>;
+    driver->ConnectionCommit = &CConnectionCommit;
+    driver->ConnectionGetInfo = &CConnectionGetInfo;
+    driver->ConnectionGetObjects = &CConnectionGetObjects;
+    driver->ConnectionGetTableSchema = &CConnectionGetTableSchema;
+    driver->ConnectionGetTableTypes = &CConnectionGetTableTypes;
+    driver->ConnectionReadPartition = &CConnectionReadPartition;
+    driver->ConnectionRollback = &CConnectionRollback;
+    driver->ConnectionCancel = &CConnectionCancel;
+    driver->ConnectionGetStatistics = &CConnectionGetStatistics;
+    driver->ConnectionGetStatisticNames = &CConnectionGetStatisticNames;
 
     // Statement lifecycle
     driver->StatementNew = &CStatementNew;
@@ -419,6 +496,13 @@ class Driver {
     driver->StatementGetOptionDouble = &CGetOptionDouble<AdbcStatement, StatementT>;
 
     driver->StatementExecuteQuery = &CStatementExecuteQuery;
+    driver->StatementExecuteSchema = &CStatementExecuteSchema;
+    driver->StatementPrepare = &CStatementPrepare;
+    driver->StatementSetSqlQuery = &CStatementSetSqlQuery;
+    driver->StatementSetSubstraitPlan = &CStatementSetSubstraitPlan;
+    driver->StatementBind = &CStatementBind;
+    driver->StatementBindStream = &CStatementBindStream;
+    driver->StatementCancel = &CStatementCancel;
 
     return ADBC_STATUS_OK;
   }
@@ -538,6 +622,82 @@ class Driver {
     return private_data->Init(database->private_data, error);
   }
 
+  static AdbcStatusCode CConnectionCancel(AdbcConnection* connection, AdbcError* error) {
+    auto private_data = reinterpret_cast<ConnectionT*>(connection->private_data);
+    return private_data->Cancel(error);
+  }
+
+  static AdbcStatusCode CConnectionGetInfo(AdbcConnection* connection,
+                                           const uint32_t* info_codes,
+                                           size_t info_codes_length,
+                                           ArrowArrayStream* out, AdbcError* error) {
+    auto private_data = reinterpret_cast<ConnectionT*>(connection->private_data);
+    return private_data->GetInfo(info_codes, info_codes_length, out, error);
+  }
+
+  static AdbcStatusCode CConnectionGetObjects(AdbcConnection* connection, int depth,
+                                              const char* catalog, const char* db_schema,
+                                              const char* table_name,
+                                              const char** table_type,
+                                              const char* column_name,
+                                              ArrowArrayStream* out, AdbcError* error) {
+    auto private_data = reinterpret_cast<ConnectionT*>(connection->private_data);
+    return private_data->GetObjects(depth, catalog, db_schema, table_name, table_type,
+                                    column_name, out, error);
+  }
+
+  static AdbcStatusCode CConnectionGetStatistics(
+      AdbcConnection* connection, const char* catalog, const char* db_schema,
+      const char* table_name, char approximate, ArrowArrayStream* out, AdbcError* error) {
+    auto private_data = reinterpret_cast<ConnectionT*>(connection->private_data);
+    return private_data->GetStatistics(catalog, db_schema, table_name, approximate, out,
+                                       error);
+  }
+
+  static AdbcStatusCode CConnectionGetStatisticNames(AdbcConnection* connection,
+                                                     ArrowArrayStream* out,
+                                                     AdbcError* error) {
+    auto private_data = reinterpret_cast<ConnectionT*>(connection->private_data);
+    return private_data->GetStatisticNames(out, error);
+  }
+
+  static AdbcStatusCode CConnectionGetTableSchema(AdbcConnection* connection,
+                                                  const char* catalog,
+                                                  const char* db_schema,
+                                                  const char* table_name,
+                                                  ArrowSchema* schema, AdbcError* error) {
+    auto private_data = reinterpret_cast<ConnectionT*>(connection->private_data);
+    return private_data->GetTableSchema(catalog, db_schema, table_name, schema, error);
+  }
+
+  static AdbcStatusCode CConnectionGetTableTypes(AdbcConnection* connection,
+                                                 ArrowArrayStream* out,
+                                                 AdbcError* error) {
+    auto private_data = reinterpret_cast<ConnectionT*>(connection->private_data);
+    return private_data->GetTableTypes(out, error);
+  }
+
+  static AdbcStatusCode CConnectionReadPartition(AdbcConnection* connection,
+                                                 const uint8_t* serialized_partition,
+                                                 size_t serialized_length,
+                                                 ArrowArrayStream* out,
+                                                 AdbcError* error) {
+    auto private_data = reinterpret_cast<ConnectionT*>(connection->private_data);
+    return private_data->ReadPartition(serialized_partition, serialized_length, out,
+                                       error);
+  }
+
+  static AdbcStatusCode CConnectionCommit(AdbcConnection* connection, AdbcError* error) {
+    auto private_data = reinterpret_cast<ConnectionT*>(connection->private_data);
+    return private_data->Commit(error);
+  }
+
+  static AdbcStatusCode CConnectionRollback(AdbcConnection* connection,
+                                            AdbcError* error) {
+    auto private_data = reinterpret_cast<ConnectionT*>(connection->private_data);
+    return private_data->Rollback(error);
+  }
+
   // Statement trampolines
   static AdbcStatusCode CStatementNew(AdbcConnection* connection,
                                       AdbcStatement* statement, AdbcError* error) {
@@ -553,12 +713,52 @@ class Driver {
   }
 
   static AdbcStatusCode CStatementExecuteQuery(AdbcStatement* statement,
-                                               struct ArrowArrayStream* stream,
-                                               int64_t* rows_affected,
-                                               struct AdbcError* error) {
+                                               ArrowArrayStream* stream,
+                                               int64_t* rows_affected, AdbcError* error) {
     auto private_data = reinterpret_cast<StatementT*>(statement->private_data);
     return private_data->ExecuteQuery(stream, rows_affected, error);
   }
+
+  static AdbcStatusCode CStatementExecuteSchema(AdbcStatement* statement,
+                                                ArrowSchema* schema, AdbcError* error) {
+    auto private_data = reinterpret_cast<StatementT*>(statement->private_data);
+    return private_data->ExecuteSchema(schema, error);
+  }
+
+  static AdbcStatusCode CStatementPrepare(AdbcStatement* statement, AdbcError* error) {
+    auto private_data = reinterpret_cast<StatementT*>(statement->private_data);
+    return private_data->Prepare(error);
+  }
+
+  static AdbcStatusCode CStatementSetSqlQuery(AdbcStatement* statement, const char* query,
+                                              AdbcError* error) {
+    auto private_data = reinterpret_cast<StatementT*>(statement->private_data);
+    return private_data->SetSqlQuery(query, error);
+  }
+
+  static AdbcStatusCode CStatementSetSubstraitPlan(AdbcStatement* statement,
+                                                   const uint8_t* plan, size_t length,
+                                                   AdbcError* error) {
+    auto private_data = reinterpret_cast<StatementT*>(statement->private_data);
+    return private_data->SetSubstraitPlan(plan, length, error);
+  }
+
+  static AdbcStatusCode CStatementBind(AdbcStatement* statement, ArrowArray* values,
+                                       ArrowSchema* schema, AdbcError* error) {
+    auto private_data = reinterpret_cast<StatementT*>(statement->private_data);
+    return private_data->Bind(values, schema, error);
+  }
+
+  static AdbcStatusCode CStatementBindStream(AdbcStatement* statement,
+                                             ArrowArrayStream* stream, AdbcError* error) {
+    auto private_data = reinterpret_cast<StatementT*>(statement->private_data);
+    return private_data->BindStream(stream, error);
+  }
+
+  static AdbcStatusCode CStatementCancel(AdbcStatement* statement, AdbcError* error) {
+    auto private_data = reinterpret_cast<StatementT*>(statement->private_data);
+    return private_data->Cancel(error);
+  }
 };
 
 }  // namespace r
diff --git a/r/adbcdrivermanager/src/driver_log.c b/r/adbcdrivermanager/src/driver_log.c
deleted file mode 100644
index 2800df15..00000000
--- a/r/adbcdrivermanager/src/driver_log.c
+++ /dev/null
@@ -1,343 +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.
-
-#define R_NO_REMAP
-#include <R.h>
-#include <Rinternals.h>
-
-#include <string.h>
-
-#include <adbc.h>
-
-struct LogDriverPrivate {
-  char token[1024];
-};
-
-struct LogDatabasePrivate {
-  char token[1024];
-};
-
-struct LogConnectionPrivate {
-  char token[1024];
-};
-
-struct LogStatementPrivate {
-  char token[1024];
-};
-
-static void ResetError(struct AdbcError* error) {
-  memset(error, 0, sizeof(struct AdbcError));
-}
-
-static void SetErrorConst(struct AdbcError* error, const char* value) {
-  if (error == NULL) {
-    return;
-  }
-
-  ResetError(error);
-  error->message = (char*)value;
-}
-
-static AdbcStatusCode LogDriverRelease(struct AdbcDriver* driver,
-                                       struct AdbcError* error) {
-  Rprintf("LogDriverRelease()\n");
-  if (driver->private_data == NULL) {
-    return ADBC_STATUS_OK;
-  }
-
-  free(driver->private_data);
-  driver->private_data = NULL;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode LogDatabaseNew(struct AdbcDatabase* database,
-                                     struct AdbcError* error) {
-  Rprintf("LogDatabaseNew()\n");
-
-  struct LogDatabasePrivate* database_private =
-      (struct LogDatabasePrivate*)malloc(sizeof(struct LogDatabasePrivate));
-  if (database_private == NULL) {
-    SetErrorConst(error, "failed to allocate LogDatabasePrivate");
-    return ADBC_STATUS_INTERNAL;
-  }
-
-  memset(database_private, 0, sizeof(struct LogDatabasePrivate));
-  database->private_data = database_private;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode LogDatabaseInit(struct AdbcDatabase* database,
-                                      struct AdbcError* error) {
-  Rprintf("LogDatabaseInit()\n");
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode LogDatabaseSetOption(struct AdbcDatabase* database, const char* key,
-                                           const char* value, struct AdbcError* error) {
-  Rprintf("LogDatabaseSetOption()\n");
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode LogDatabaseRelease(struct AdbcDatabase* database,
-                                         struct AdbcError* error) {
-  Rprintf("LogDatabaseRelease()\n");
-  if (database->private_data == NULL) {
-    return ADBC_STATUS_OK;
-  }
-
-  free(database->private_data);
-  database->private_data = NULL;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode LogConnectionCommit(struct AdbcConnection* connection,
-                                          struct AdbcError* error) {
-  Rprintf("LogConnectionCommit()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode LogConnectionGetInfo(struct AdbcConnection* connection,
-                                           const uint32_t* info_codes,
-                                           size_t info_codes_length,
-                                           struct ArrowArrayStream* stream,
-                                           struct AdbcError* error) {
-  Rprintf("LogConnectionGetInfo()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode LogConnectionGetObjects(
-    struct AdbcConnection* connection, int depth, const char* catalog,
-    const char* db_schema, const char* table_name, const char** table_types,
-    const char* column_name, struct ArrowArrayStream* stream, struct AdbcError* error) {
-  Rprintf("LogConnectionGetObjects()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode LogConnectionGetTableSchema(
-    struct AdbcConnection* connection, const char* catalog, const char* db_schema,
-    const char* table_name, struct ArrowSchema* schema, struct AdbcError* error) {
-  Rprintf("LogConnectionGetTableSchema()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode LogConnectionGetTableTypes(struct AdbcConnection* connection,
-                                                 struct ArrowArrayStream* stream,
-                                                 struct AdbcError* error) {
-  Rprintf("LogConnectionGetTableTypes()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode LogConnectionInit(struct AdbcConnection* connection,
-                                        struct AdbcDatabase* database,
-                                        struct AdbcError* error) {
-  Rprintf("LogConnectionInit()\n");
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode LogConnectionNew(struct AdbcConnection* connection,
-                                       struct AdbcError* error) {
-  Rprintf("LogConnectionNew()\n");
-
-  struct LogConnectionPrivate* connection_private =
-      (struct LogConnectionPrivate*)malloc(sizeof(struct LogConnectionPrivate));
-  if (connection_private == NULL) {
-    SetErrorConst(error, "failed to allocate LogConnectionPrivate");
-    return ADBC_STATUS_INTERNAL;
-  }
-
-  memset(connection_private, 0, sizeof(struct LogConnectionPrivate));
-  connection->private_data = connection_private;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode LogConnectionReadPartition(struct AdbcConnection* connection,
-                                                 const uint8_t* serialized_partition,
-                                                 size_t serialized_length,
-                                                 struct ArrowArrayStream* out,
-                                                 struct AdbcError* error) {
-  Rprintf("LogConnectionReadPartition()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode LogConnectionRelease(struct AdbcConnection* connection,
-                                           struct AdbcError* error) {
-  Rprintf("LogConnectionRelease()\n");
-  if (connection->private_data == NULL) {
-    return ADBC_STATUS_OK;
-  }
-
-  free(connection->private_data);
-  connection->private_data = NULL;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode LogConnectionRollback(struct AdbcConnection* connection,
-                                            struct AdbcError* error) {
-  Rprintf("LogConnectionRollback()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode LogConnectionSetOption(struct AdbcConnection* connection,
-                                             const char* key, const char* value,
-                                             struct AdbcError* error) {
-  Rprintf("LogConnectionSetOption()\n");
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode LogStatementBind(struct AdbcStatement* statement,
-                                       struct ArrowArray* values,
-                                       struct ArrowSchema* schema,
-                                       struct AdbcError* error) {
-  Rprintf("LogStatementBind()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}  // NOLINT(whitespace/indent)
-
-static AdbcStatusCode LogStatementBindStream(struct AdbcStatement* statement,
-                                             struct ArrowArrayStream* stream,
-                                             struct AdbcError* error) {
-  Rprintf("LogStatementBindStream()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode LogStatementExecutePartitions(struct AdbcStatement* statement,
-                                                    struct ArrowSchema* schema,
-                                                    struct AdbcPartitions* partitions,
-                                                    int64_t* rows_affected,
-                                                    struct AdbcError* error) {
-  Rprintf("LogStatementExecutePartitions()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}  // NOLINT(whitespace/indent)
-
-static AdbcStatusCode LogStatementExecuteQuery(struct AdbcStatement* statement,
-                                               struct ArrowArrayStream* out,
-                                               int64_t* rows_affected,
-                                               struct AdbcError* error) {
-  Rprintf("LogStatementExecuteQuery()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode LogStatementGetParameterSchema(struct AdbcStatement* statement,
-                                                     struct ArrowSchema* schema,
-                                                     struct AdbcError* error) {
-  Rprintf("LogStatementGetParameterSchema()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode LogStatementNew(struct AdbcConnection* connection,
-                                      struct AdbcStatement* statement,
-                                      struct AdbcError* error) {
-  Rprintf("LogStatementNew()\n");
-  struct LogStatementPrivate* statement_private =
-      (struct LogStatementPrivate*)malloc(sizeof(struct LogStatementPrivate));
-  if (statement_private == NULL) {
-    SetErrorConst(error, "failed to allocate LogStatementPrivate");
-    return ADBC_STATUS_INTERNAL;
-  }
-
-  memset(statement_private, 0, sizeof(struct LogStatementPrivate));
-  statement->private_data = statement_private;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode LogStatementPrepare(struct AdbcStatement* statement,
-                                          struct AdbcError* error) {
-  Rprintf("LogStatementPrepare()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode LogStatementRelease(struct AdbcStatement* statement,
-                                          struct AdbcError* error) {
-  Rprintf("LogStatementRelease()\n");
-  if (statement->private_data == NULL) {
-    return ADBC_STATUS_OK;
-  }
-
-  free(statement->private_data);
-  statement->private_data = NULL;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode LogStatementSetOption(struct AdbcStatement* statement,
-                                            const char* key, const char* value,
-                                            struct AdbcError* error) {
-  Rprintf("LogStatementSetOption()\n");
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode LogStatementSetSqlQuery(struct AdbcStatement* statement,
-                                              const char* query,
-                                              struct AdbcError* error) {
-  Rprintf("LogStatementSetSqlQuery()\n");
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode LogDriverInitFunc(int version, void* raw_driver,
-                                        struct AdbcError* error) {
-  if (version != ADBC_VERSION_1_1_0) return ADBC_STATUS_NOT_IMPLEMENTED;
-  struct AdbcDriver* driver = (struct AdbcDriver*)raw_driver;
-  memset(driver, 0, sizeof(struct AdbcDriver));
-
-  struct LogDriverPrivate* driver_private =
-      (struct LogDriverPrivate*)malloc(sizeof(struct LogDriverPrivate));
-  if (driver_private == NULL) {
-    SetErrorConst(error, "failed to allocate LogDriverPrivate");
-    return ADBC_STATUS_INTERNAL;
-  }
-
-  memset(driver_private, 0, sizeof(struct LogDriverPrivate));
-  driver->private_data = driver_private;
-
-  driver->DatabaseInit = &LogDatabaseInit;
-  driver->DatabaseNew = LogDatabaseNew;
-  driver->DatabaseRelease = LogDatabaseRelease;
-  driver->DatabaseSetOption = LogDatabaseSetOption;
-
-  driver->ConnectionCommit = LogConnectionCommit;
-  driver->ConnectionGetInfo = LogConnectionGetInfo;
-  driver->ConnectionGetObjects = LogConnectionGetObjects;
-  driver->ConnectionGetTableSchema = LogConnectionGetTableSchema;
-  driver->ConnectionGetTableTypes = LogConnectionGetTableTypes;
-  driver->ConnectionInit = LogConnectionInit;
-  driver->ConnectionNew = LogConnectionNew;
-  driver->ConnectionReadPartition = LogConnectionReadPartition;
-  driver->ConnectionRelease = LogConnectionRelease;
-  driver->ConnectionRollback = LogConnectionRollback;
-  driver->ConnectionSetOption = LogConnectionSetOption;
-
-  driver->StatementBind = LogStatementBind;
-  driver->StatementBindStream = LogStatementBindStream;
-  driver->StatementExecutePartitions = LogStatementExecutePartitions;
-  driver->StatementExecuteQuery = LogStatementExecuteQuery;
-  driver->StatementGetParameterSchema = LogStatementGetParameterSchema;
-  driver->StatementNew = LogStatementNew;
-  driver->StatementPrepare = LogStatementPrepare;
-  driver->StatementRelease = LogStatementRelease;
-  driver->StatementSetOption = LogStatementSetOption;
-  driver->StatementSetSqlQuery = LogStatementSetSqlQuery;
-
-  driver->release = LogDriverRelease;
-
-  return ADBC_STATUS_OK;
-}
-
-SEXP RAdbcLogDriverInitFunc(void) {
-  SEXP xptr =
-      PROTECT(R_MakeExternalPtrFn((DL_FUNC)LogDriverInitFunc, R_NilValue, R_NilValue));
-  Rf_setAttrib(xptr, R_ClassSymbol, Rf_mkString("adbc_driver_init_func"));
-  UNPROTECT(1);
-  return xptr;
-}
diff --git a/r/adbcdrivermanager/src/driver_monkey.c b/r/adbcdrivermanager/src/driver_monkey.c
deleted file mode 100644
index 6ce09f2c..00000000
--- a/r/adbcdrivermanager/src/driver_monkey.c
+++ /dev/null
@@ -1,342 +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.
-
-#define R_NO_REMAP
-#include <R.h>
-#include <Rinternals.h>
-
-#include <string.h>
-
-#include <adbc.h>
-
-struct MonkeyDriverPrivate {
-  char token[1024];
-};
-
-struct MonkeyDatabasePrivate {
-  char token[1024];
-};
-
-struct MonkeyConnectionPrivate {
-  char token[1024];
-};
-
-struct MonkeyStatementPrivate {
-  struct ArrowArrayStream stream;
-};
-
-static void ResetError(struct AdbcError* error) {
-  memset(error, 0, sizeof(struct AdbcError));
-}
-
-static void SetErrorConst(struct AdbcError* error, const char* value) {
-  if (error == NULL) {
-    return;
-  }
-
-  ResetError(error);
-  error->message = (char*)value;
-}
-
-static AdbcStatusCode MonkeyDriverRelease(struct AdbcDriver* driver,
-                                          struct AdbcError* error) {
-  if (driver->private_data == NULL) {
-    return ADBC_STATUS_OK;
-  }
-
-  free(driver->private_data);
-  driver->private_data = NULL;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode MonkeyDatabaseNew(struct AdbcDatabase* database,
-                                        struct AdbcError* error) {
-  struct MonkeyDatabasePrivate* database_private =
-      (struct MonkeyDatabasePrivate*)malloc(sizeof(struct MonkeyDatabasePrivate));
-  if (database_private == NULL) {
-    SetErrorConst(error, "failed to allocate MonkeyDatabasePrivate");
-    return ADBC_STATUS_INTERNAL;
-  }
-
-  memset(database_private, 0, sizeof(struct MonkeyDatabasePrivate));
-  database->private_data = database_private;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode MonkeyDatabaseInit(struct AdbcDatabase* database,
-                                         struct AdbcError* error) {
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode MonkeyDatabaseSetOption(struct AdbcDatabase* database,
-                                              const char* key, const char* value,
-                                              struct AdbcError* error) {
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode MonkeyDatabaseRelease(struct AdbcDatabase* database,
-                                            struct AdbcError* error) {
-  if (database->private_data == NULL) {
-    return ADBC_STATUS_OK;
-  }
-
-  free(database->private_data);
-  database->private_data = NULL;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode MonkeyConnectionCommit(struct AdbcConnection* connection,
-                                             struct AdbcError* error) {
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode MonkeyConnectionGetInfo(struct AdbcConnection* connection,
-                                              const uint32_t* info_codes,
-                                              size_t info_codes_length,
-                                              struct ArrowArrayStream* stream,
-                                              struct AdbcError* error) {
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode MonkeyConnectionGetObjects(
-    struct AdbcConnection* connection, int depth, const char* catalog,
-    const char* db_schema, const char* table_name, const char** table_types,
-    const char* column_name, struct ArrowArrayStream* stream, struct AdbcError* error) {
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode MonkeyConnectionGetTableSchema(
-    struct AdbcConnection* connection, const char* catalog, const char* db_schema,
-    const char* table_name, struct ArrowSchema* schema, struct AdbcError* error) {
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode MonkeyConnectionGetTableTypes(struct AdbcConnection* connection,
-                                                    struct ArrowArrayStream* stream,
-                                                    struct AdbcError* error) {
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode MonkeyConnectionInit(struct AdbcConnection* connection,
-                                           struct AdbcDatabase* database,
-                                           struct AdbcError* error) {
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode MonkeyConnectionNew(struct AdbcConnection* connection,
-                                          struct AdbcError* error) {
-  struct MonkeyConnectionPrivate* connection_private =
-      (struct MonkeyConnectionPrivate*)malloc(sizeof(struct MonkeyConnectionPrivate));
-  if (connection_private == NULL) {
-    SetErrorConst(error, "failed to allocate MonkeyConnectionPrivate");
-    return ADBC_STATUS_INTERNAL;
-  }
-
-  memset(connection_private, 0, sizeof(struct MonkeyConnectionPrivate));
-  connection->private_data = connection_private;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode MonkeyConnectionReadPartition(struct AdbcConnection* connection,
-                                                    const uint8_t* serialized_partition,
-                                                    size_t serialized_length,
-                                                    struct ArrowArrayStream* out,
-                                                    struct AdbcError* error) {
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode MonkeyConnectionRelease(struct AdbcConnection* connection,
-                                              struct AdbcError* error) {
-  if (connection->private_data == NULL) {
-    return ADBC_STATUS_OK;
-  }
-
-  free(connection->private_data);
-  connection->private_data = NULL;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode MonkeyConnectionRollback(struct AdbcConnection* connection,
-                                               struct AdbcError* error) {
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode MonkeyConnectionSetOption(struct AdbcConnection* connection,
-                                                const char* key, const char* value,
-                                                struct AdbcError* error) {
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode MonkeyStatementBind(struct AdbcStatement* statement,
-                                          struct ArrowArray* values,
-                                          struct ArrowSchema* schema,
-                                          struct AdbcError* error) {
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}  // NOLINT(whitespace/indent)
-
-static AdbcStatusCode MonkeyStatementBindStream(struct AdbcStatement* statement,
-                                                struct ArrowArrayStream* stream,
-                                                struct AdbcError* error) {
-  struct MonkeyStatementPrivate* statement_private =
-      (struct MonkeyStatementPrivate*)statement->private_data;
-  if (statement_private->stream.release != NULL) {
-    statement_private->stream.release(&statement_private->stream);
-  }
-
-  memcpy(&statement_private->stream, stream, sizeof(struct ArrowArrayStream));
-  stream->release = NULL;
-
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode MonkeyStatementExecutePartitions(struct AdbcStatement* statement,
-                                                       struct ArrowSchema* schema,
-                                                       struct AdbcPartitions* partitions,
-                                                       int64_t* rows_affected,
-                                                       struct AdbcError* error) {
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}  // NOLINT(whitespace/indent)
-
-static AdbcStatusCode MonkeyStatementExecuteQuery(struct AdbcStatement* statement,
-                                                  struct ArrowArrayStream* out,
-                                                  int64_t* rows_affected,
-                                                  struct AdbcError* error) {
-  if (out == NULL) {
-    *rows_affected = 0;
-    return ADBC_STATUS_OK;
-  }
-
-  struct MonkeyStatementPrivate* statement_private =
-      (struct MonkeyStatementPrivate*)statement->private_data;
-
-  memcpy(out, &statement_private->stream, sizeof(struct ArrowArrayStream));
-  statement_private->stream.release = NULL;
-  *rows_affected = -1;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode MonkeyStatementGetParameterSchema(struct AdbcStatement* statement,
-                                                        struct ArrowSchema* schema,
-                                                        struct AdbcError* error) {
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode MonkeyStatementNew(struct AdbcConnection* connection,
-                                         struct AdbcStatement* statement,
-                                         struct AdbcError* error) {
-  struct MonkeyStatementPrivate* statement_private =
-      (struct MonkeyStatementPrivate*)malloc(sizeof(struct MonkeyStatementPrivate));
-  if (statement_private == NULL) {
-    SetErrorConst(error, "failed to allocate MonkeyStatementPrivate");
-    return ADBC_STATUS_INTERNAL;
-  }
-
-  memset(statement_private, 0, sizeof(struct MonkeyStatementPrivate));
-  statement->private_data = statement_private;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode MonkeyStatementPrepare(struct AdbcStatement* statement,
-                                             struct AdbcError* error) {
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode MonkeyStatementRelease(struct AdbcStatement* statement,
-                                             struct AdbcError* error) {
-  if (statement->private_data == NULL) {
-    return ADBC_STATUS_OK;
-  }
-
-  struct MonkeyStatementPrivate* statement_private =
-      (struct MonkeyStatementPrivate*)statement->private_data;
-  if (statement_private->stream.release != NULL) {
-    statement_private->stream.release(&statement_private->stream);
-  }
-
-  free(statement->private_data);
-  statement->private_data = NULL;
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode MonkeyStatementSetOption(struct AdbcStatement* statement,
-                                               const char* key, const char* value,
-                                               struct AdbcError* error) {
-  return ADBC_STATUS_NOT_IMPLEMENTED;
-}
-
-static AdbcStatusCode MonkeyStatementSetSqlQuery(struct AdbcStatement* statement,
-                                                 const char* query,
-                                                 struct AdbcError* error) {
-  return ADBC_STATUS_OK;
-}
-
-static AdbcStatusCode MonkeyDriverInitFunc(int version, void* raw_driver,
-                                           struct AdbcError* error) {
-  if (version != ADBC_VERSION_1_1_0) return ADBC_STATUS_NOT_IMPLEMENTED;
-  struct AdbcDriver* driver = (struct AdbcDriver*)raw_driver;
-  memset(driver, 0, sizeof(struct AdbcDriver));
-
-  struct MonkeyDriverPrivate* driver_private =
-      (struct MonkeyDriverPrivate*)malloc(sizeof(struct MonkeyDriverPrivate));
-  if (driver_private == NULL) {
-    SetErrorConst(error, "failed to allocate MonkeyDriverPrivate");
-    return ADBC_STATUS_INTERNAL;
-  }
-
-  memset(driver_private, 0, sizeof(struct MonkeyDriverPrivate));
-  driver->private_data = driver_private;
-
-  driver->DatabaseInit = &MonkeyDatabaseInit;
-  driver->DatabaseNew = MonkeyDatabaseNew;
-  driver->DatabaseRelease = MonkeyDatabaseRelease;
-  driver->DatabaseSetOption = MonkeyDatabaseSetOption;
-
-  driver->ConnectionCommit = MonkeyConnectionCommit;
-  driver->ConnectionGetInfo = MonkeyConnectionGetInfo;
-  driver->ConnectionGetObjects = MonkeyConnectionGetObjects;
-  driver->ConnectionGetTableSchema = MonkeyConnectionGetTableSchema;
-  driver->ConnectionGetTableTypes = MonkeyConnectionGetTableTypes;
-  driver->ConnectionInit = MonkeyConnectionInit;
-  driver->ConnectionNew = MonkeyConnectionNew;
-  driver->ConnectionReadPartition = MonkeyConnectionReadPartition;
-  driver->ConnectionRelease = MonkeyConnectionRelease;
-  driver->ConnectionRollback = MonkeyConnectionRollback;
-  driver->ConnectionSetOption = MonkeyConnectionSetOption;
-
-  driver->StatementBind = MonkeyStatementBind;
-  driver->StatementBindStream = MonkeyStatementBindStream;
-  driver->StatementExecutePartitions = MonkeyStatementExecutePartitions;
-  driver->StatementExecuteQuery = MonkeyStatementExecuteQuery;
-  driver->StatementGetParameterSchema = MonkeyStatementGetParameterSchema;
-  driver->StatementNew = MonkeyStatementNew;
-  driver->StatementPrepare = MonkeyStatementPrepare;
-  driver->StatementRelease = MonkeyStatementRelease;
-  driver->StatementSetOption = MonkeyStatementSetOption;
-  driver->StatementSetSqlQuery = MonkeyStatementSetSqlQuery;
-
-  driver->release = MonkeyDriverRelease;
-
-  return ADBC_STATUS_OK;
-}
-
-SEXP RAdbcMonkeyDriverInitFunc(void) {
-  SEXP xptr =
-      PROTECT(R_MakeExternalPtrFn((DL_FUNC)MonkeyDriverInitFunc, R_NilValue, R_NilValue));
-  Rf_setAttrib(xptr, R_ClassSymbol, Rf_mkString("adbc_driver_init_func"));
-  UNPROTECT(1);
-  return xptr;
-}
diff --git a/r/adbcdrivermanager/src/driver_test.cc b/r/adbcdrivermanager/src/driver_test.cc
new file mode 100644
index 00000000..2605891d
--- /dev/null
+++ b/r/adbcdrivermanager/src/driver_test.cc
@@ -0,0 +1,283 @@
+// 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.
+
+#define R_NO_REMAP
+#include <R.h>
+#include <Rinternals.h>
+
+#include <cstring>
+
+#include "driver_base.h"
+
+#include <adbc.h>
+
+using adbc::r::Option;
+
+using VoidDriver =
+    adbc::r::Driver<adbc::r::DatabaseObjectBase, adbc::r::ConnectionObjectBase,
+                    adbc::r::StatementObjectBase>;
+
+static AdbcStatusCode VoidDriverInitFunc(int version, void* raw_driver,
+                                         AdbcError* error) {
+  return VoidDriver::Init(version, raw_driver, error);
+}
+
+extern "C" SEXP RAdbcVoidDriverInitFunc(void) {
+  SEXP xptr =
+      PROTECT(R_MakeExternalPtrFn((DL_FUNC)VoidDriverInitFunc, R_NilValue, R_NilValue));
+  Rf_setAttrib(xptr, R_ClassSymbol, Rf_mkString("adbc_driver_init_func"));
+  UNPROTECT(1);
+  return xptr;
+}
+
+class MonkeyDriverStatement : public adbc::r::StatementObjectBase {
+ public:
+  MonkeyDriverStatement() { stream_.release = nullptr; }
+
+  ~MonkeyDriverStatement() {
+    if (stream_.release != nullptr) {
+      stream_.release(&stream_);
+    }
+  }
+
+  AdbcStatusCode BindStream(ArrowArrayStream* stream, AdbcError* error) {
+    if (stream_.release != nullptr) {
+      stream_.release(&stream_);
+    }
+
+    std::memcpy(&stream_, stream, sizeof(ArrowArrayStream));
+    stream->release = nullptr;
+    return ADBC_STATUS_OK;
+  }
+
+  AdbcStatusCode ExecuteQuery(ArrowArrayStream* stream, int64_t* rows_affected,
+                              AdbcError* error) {
+    if (stream != nullptr) {
+      std::memcpy(stream, &stream_, sizeof(ArrowArrayStream));
+      stream_.release = nullptr;
+    }
+
+    if (rows_affected != nullptr) {
+      *rows_affected = -1;
+    }
+
+    return ADBC_STATUS_OK;
+  }
+
+ private:
+  ArrowArrayStream stream_;
+};
+
+using MonkeyDriver =
+    adbc::r::Driver<adbc::r::DatabaseObjectBase, adbc::r::ConnectionObjectBase,
+                    MonkeyDriverStatement>;
+
+static AdbcStatusCode MonkeyDriverInitFunc(int version, void* raw_driver,
+                                           AdbcError* error) {
+  return MonkeyDriver::Init(version, raw_driver, error);
+}
+
+extern "C" SEXP RAdbcMonkeyDriverInitFunc(void) {
+  SEXP xptr =
+      PROTECT(R_MakeExternalPtrFn((DL_FUNC)MonkeyDriverInitFunc, R_NilValue, R_NilValue));
+  Rf_setAttrib(xptr, R_ClassSymbol, Rf_mkString("adbc_driver_init_func"));
+  UNPROTECT(1);
+  return xptr;
+}
+
+class LogDriverDatabase : public adbc::r::DatabaseObjectBase {
+ public:
+  LogDriverDatabase() { Rprintf("LogDatabaseNew()\n"); }
+
+  ~LogDriverDatabase() { Rprintf("LogDatabaseRelease()\n"); }
+
+  AdbcStatusCode Init(void* parent, AdbcError* error) {
+    Rprintf("LogDatabaseInit()\n");
+    return adbc::r::DatabaseObjectBase::Init(parent, error);
+  }
+
+  const Option& GetOption(const std::string& key,
+                          const Option& default_value = Option()) const {
+    Rprintf("LogDatabaseGetOption()\n");
+    return adbc::r::DatabaseObjectBase::GetOption(key, default_value);
+  }
+
+  AdbcStatusCode SetOption(const std::string& key, const Option& value) {
+    Rprintf("LogDatabaseSetOption()\n");
+    return adbc::r::DatabaseObjectBase::SetOption(key, value);
+  }
+};
+
+class LogDriverConnection : public adbc::r::ConnectionObjectBase {
+ public:
+  LogDriverConnection() { Rprintf("LogConnectionNew()\n"); }
+
+  ~LogDriverConnection() { Rprintf("LogConnectionRelease()\n"); }
+
+  AdbcStatusCode Init(void* parent, AdbcError* error) {
+    Rprintf("LogConnectionInit()\n");
+    return adbc::r::ConnectionObjectBase::Init(parent, error);
+  }
+
+  const Option& GetOption(const std::string& key,
+                          const Option& default_value = Option()) const {
+    Rprintf("LogConnectionGetOption()\n");
+    return adbc::r::ConnectionObjectBase::GetOption(key, default_value);
+  }
+
+  AdbcStatusCode SetOption(const std::string& key, const Option& value) {
+    Rprintf("LogConnectionSetOption()\n");
+    return adbc::r::ConnectionObjectBase::SetOption(key, value);
+  }
+
+  AdbcStatusCode Commit(AdbcError* error) {
+    Rprintf("LogConnectionCommit()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode GetInfo(const uint32_t* info_codes, size_t info_codes_length,
+                         ArrowArrayStream* out, AdbcError* error) {
+    Rprintf("LogConnectionGetInfo()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode GetObjects(int depth, const char* catalog, const char* db_schema,
+                            const char* table_name, const char** table_type,
+                            const char* column_name, ArrowArrayStream* out,
+                            AdbcError* error) {
+    Rprintf("LogConnectionGetObjects()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode GetTableSchema(const char* catalog, const char* db_schema,
+                                const char* table_name, ArrowSchema* schema,
+                                AdbcError* error) {
+    Rprintf("LogConnectionGetTableSchema()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode GetTableTypes(ArrowArrayStream* out, AdbcError* error) {
+    Rprintf("LogConnectionGetTableTypes()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode ReadPartition(const uint8_t* serialized_partition,
+                               size_t serialized_length, ArrowArrayStream* out,
+                               AdbcError* error) {
+    Rprintf("LogConnectionReadPartition()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode Rollback(AdbcError* error) {
+    Rprintf("LogConnectionRollback()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode Cancel(AdbcError* error) {
+    Rprintf("LogConnectionCancel()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode GetStatistics(const char* catalog, const char* db_schema,
+                               const char* table_name, char approximate,
+                               ArrowArrayStream* out, AdbcError* error) {
+    Rprintf("LogConnectionGetStatistics()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode GetStatisticNames(ArrowArrayStream* out, AdbcError* error) {
+    Rprintf("LogConnectionGetStatisticNames()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+};
+
+class LogDriverStatement : public adbc::r::StatementObjectBase {
+ public:
+  ~LogDriverStatement() { Rprintf("LogStatementRelease()\n"); }
+
+  AdbcStatusCode Init(void* parent, AdbcError* error) {
+    Rprintf("LogStatementNew()\n");
+    return adbc::r::StatementObjectBase::Init(parent, error);
+  }
+
+  const Option& GetOption(const std::string& key,
+                          const Option& default_value = Option()) const {
+    Rprintf("LogStatementGetOption()\n");
+    return adbc::r::StatementObjectBase::GetOption(key, default_value);
+  }
+
+  AdbcStatusCode SetOption(const std::string& key, const Option& value) {
+    Rprintf("LogStatementSetOption()\n");
+    return adbc::r::StatementObjectBase::SetOption(key, value);
+  }
+
+  AdbcStatusCode ExecuteQuery(ArrowArrayStream* stream, int64_t* rows_affected,
+                              AdbcError* error) {
+    Rprintf("LogStatementExecuteQuery()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode ExecuteSchema(ArrowSchema* schema, AdbcError* error) {
+    Rprintf("LogStatementExecuteSchema()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode Prepare(AdbcError* error) {
+    Rprintf("LogStatementPrepare()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode SetSqlQuery(const char* query, AdbcError* error) {
+    Rprintf("LogStatementSetSqlQuery()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode SetSubstraitPlan(const uint8_t* plan, size_t length, AdbcError* error) {
+    Rprintf("LogStatementSetSubstraitPlan()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode Bind(ArrowArray* values, ArrowSchema* schema, AdbcError* error) {
+    Rprintf("LogStatementBind()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode BindStream(ArrowArrayStream* stream, AdbcError* error) {
+    Rprintf("LogStatementBindStream()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+
+  AdbcStatusCode Cancel(AdbcError* error) {
+    Rprintf("LogStatementCancel()\n");
+    return ADBC_STATUS_NOT_IMPLEMENTED;
+  }
+};
+
+using LogDriver =
+    adbc::r::Driver<LogDriverDatabase, LogDriverConnection, LogDriverStatement>;
+
+static AdbcStatusCode LogDriverInitFunc(int version, void* raw_driver, AdbcError* error) {
+  return LogDriver::Init(version, raw_driver, error);
+}
+
+extern "C" SEXP RAdbcLogDriverInitFunc(void) {
+  SEXP xptr =
+      PROTECT(R_MakeExternalPtrFn((DL_FUNC)LogDriverInitFunc, R_NilValue, R_NilValue));
+  Rf_setAttrib(xptr, R_ClassSymbol, Rf_mkString("adbc_driver_init_func"));
+  UNPROTECT(1);
+  return xptr;
+}
diff --git a/r/adbcdrivermanager/src/driver_void.cc b/r/adbcdrivermanager/src/driver_void.cc
deleted file mode 100644
index 5898cb87..00000000
--- a/r/adbcdrivermanager/src/driver_void.cc
+++ /dev/null
@@ -1,41 +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.
-
-#define R_NO_REMAP
-#include <R.h>
-#include <Rinternals.h>
-
-#include "driver_base.h"
-
-#include <adbc.h>
-
-using VoidDriver =
-    adbc::r::Driver<adbc::r::DatabaseObjectBase, adbc::r::ConnectionObjectBase,
-                    adbc::r::StatementObjectBase>;
-
-static AdbcStatusCode VoidDriverInitFunc(int version, void* raw_driver,
-                                         struct AdbcError* error) {
-  return VoidDriver::Init(version, raw_driver, error);
-}
-
-extern "C" SEXP RAdbcVoidDriverInitFunc(void) {
-  SEXP xptr =
-      PROTECT(R_MakeExternalPtrFn((DL_FUNC)VoidDriverInitFunc, R_NilValue, R_NilValue));
-  Rf_setAttrib(xptr, R_ClassSymbol, Rf_mkString("adbc_driver_init_func"));
-  UNPROTECT(1);
-  return xptr;
-}
diff --git a/r/adbcdrivermanager/src/init.c b/r/adbcdrivermanager/src/init.c
index 50319054..77c097b8 100644
--- a/r/adbcdrivermanager/src/init.c
+++ b/r/adbcdrivermanager/src/init.c
@@ -20,9 +20,9 @@
 #include <Rinternals.h>
 
 /* generated by tools/make-callentries.R */
-SEXP RAdbcLogDriverInitFunc(void);
-SEXP RAdbcMonkeyDriverInitFunc(void);
 SEXP RAdbcVoidDriverInitFunc(void);
+SEXP RAdbcMonkeyDriverInitFunc(void);
+SEXP RAdbcLogDriverInitFunc(void);
 SEXP RAdbcAllocateError(SEXP shelter_sexp, SEXP use_legacy_error_sexp);
 SEXP RAdbcErrorProxy(SEXP error_xptr);
 SEXP RAdbcErrorFromArrayStream(SEXP stream_xptr);
@@ -97,12 +97,13 @@ SEXP RAdbcStatementExecuteSchema(SEXP statement_xptr, SEXP out_schema_xptr,
                                  SEXP error_xptr);
 SEXP RAdbcStatementExecutePartitions(SEXP statement_xptr, SEXP out_schema_xptr,
                                      SEXP partitions_xptr, SEXP error_xptr);
+SEXP RAdbcStatementCancel(SEXP statement_xptr, SEXP error_xptr);
 SEXP RAdbcXptrEnv(SEXP xptr);
 
 static const R_CallMethodDef CallEntries[] = {
-    {"RAdbcLogDriverInitFunc", (DL_FUNC)&RAdbcLogDriverInitFunc, 0},
-    {"RAdbcMonkeyDriverInitFunc", (DL_FUNC)&RAdbcMonkeyDriverInitFunc, 0},
     {"RAdbcVoidDriverInitFunc", (DL_FUNC)&RAdbcVoidDriverInitFunc, 0},
+    {"RAdbcMonkeyDriverInitFunc", (DL_FUNC)&RAdbcMonkeyDriverInitFunc, 0},
+    {"RAdbcLogDriverInitFunc", (DL_FUNC)&RAdbcLogDriverInitFunc, 0},
     {"RAdbcAllocateError", (DL_FUNC)&RAdbcAllocateError, 2},
     {"RAdbcErrorProxy", (DL_FUNC)&RAdbcErrorProxy, 1},
     {"RAdbcErrorFromArrayStream", (DL_FUNC)&RAdbcErrorFromArrayStream, 1},
@@ -157,6 +158,7 @@ static const R_CallMethodDef CallEntries[] = {
     {"RAdbcStatementExecuteQuery", (DL_FUNC)&RAdbcStatementExecuteQuery, 3},
     {"RAdbcStatementExecuteSchema", (DL_FUNC)&RAdbcStatementExecuteSchema, 3},
     {"RAdbcStatementExecutePartitions", (DL_FUNC)&RAdbcStatementExecutePartitions, 4},
+    {"RAdbcStatementCancel", (DL_FUNC)&RAdbcStatementCancel, 2},
     {"RAdbcXptrEnv", (DL_FUNC)&RAdbcXptrEnv, 1},
     {NULL, NULL, 0}};
 /* end generated by tools/make-callentries.R */
diff --git a/r/adbcdrivermanager/src/radbc.cc b/r/adbcdrivermanager/src/radbc.cc
index 368d5503..fe09de13 100644
--- a/r/adbcdrivermanager/src/radbc.cc
+++ b/r/adbcdrivermanager/src/radbc.cc
@@ -534,3 +534,10 @@ extern "C" SEXP RAdbcStatementExecutePartitions(SEXP statement_xptr, SEXP out_sc
                                                 SEXP partitions_xptr, SEXP error_xptr) {
   return adbc_wrap_status(ADBC_STATUS_NOT_IMPLEMENTED);
 }
+
+extern "C" SEXP RAdbcStatementCancel(SEXP statement_xptr, SEXP error_xptr) {
+  auto statement = adbc_from_xptr<AdbcStatement>(statement_xptr);
+  auto error = adbc_from_xptr<AdbcError>(error_xptr);
+  int status = AdbcStatementCancel(statement, error);
+  return adbc_wrap_status(status);
+}
diff --git a/r/adbcdrivermanager/tests/testthat/_snaps/driver_log.md b/r/adbcdrivermanager/tests/testthat/_snaps/driver_log.md
index 74527250..82b7e604 100644
--- a/r/adbcdrivermanager/tests/testthat/_snaps/driver_log.md
+++ b/r/adbcdrivermanager/tests/testthat/_snaps/driver_log.md
@@ -6,22 +6,124 @@
       LogDatabaseNew()
       LogDatabaseSetOption()
       LogDatabaseInit()
+    Code
+      expect_identical(adbc_database_get_option(db, "key"), "value")
+    Output
+      LogDatabaseGetOption()
+      LogDatabaseGetOption()
     Code
       con <- adbc_connection_init(db, key = "value")
     Output
       LogConnectionNew()
       LogConnectionSetOption()
       LogConnectionInit()
+    Code
+      expect_identical(adbc_connection_get_option(con, "key"), "value")
+    Output
+      LogConnectionGetOption()
+      LogConnectionGetOption()
+    Code
+      try(adbc_connection_commit(con))
+    Output
+      LogConnectionCommit()
+      Error in adbc_connection_commit(con) : NOT_IMPLEMENTED
+    Code
+      try(adbc_connection_get_info(con))
+    Output
+      LogConnectionGetInfo()
+      Error in adbc_connection_get_info(con) : NOT_IMPLEMENTED
+    Code
+      try(adbc_connection_get_objects(con))
+    Output
+      LogConnectionGetObjects()
+      Error in adbc_connection_get_objects(con) : NOT_IMPLEMENTED
+    Code
+      try(adbc_connection_get_table_schema(con, NULL, NULL, "table_name"))
+    Output
+      LogConnectionGetTableSchema()
+      Error in adbc_connection_get_table_schema(con, NULL, NULL, "table_name") : 
+        NOT_IMPLEMENTED
+    Code
+      try(adbc_connection_get_table_types(con))
+    Output
+      LogConnectionGetTableTypes()
+      Error in adbc_connection_get_table_types(con) : NOT_IMPLEMENTED
+    Code
+      try(adbc_connection_read_partition(con, raw()))
+    Output
+      LogConnectionReadPartition()
+      Error in adbc_connection_read_partition(con, raw()) : NOT_IMPLEMENTED
+    Code
+      try(adbc_connection_rollback(con))
+    Output
+      LogConnectionRollback()
+      Error in adbc_connection_rollback(con) : NOT_IMPLEMENTED
+    Code
+      try(adbc_connection_cancel(con))
+    Output
+      LogConnectionCancel()
+      Error in adbc_connection_cancel(con) : NOT_IMPLEMENTED
+    Code
+      try(adbc_connection_get_statistics(con, NULL, NULL, "table_name"))
+    Output
+      LogConnectionGetStatistics()
+      Error in adbc_connection_get_statistics(con, NULL, NULL, "table_name") : 
+        NOT_IMPLEMENTED
+    Code
+      try(adbc_connection_get_statistic_names(con))
+    Output
+      LogConnectionGetStatisticNames()
+      Error in adbc_connection_get_statistic_names(con) : NOT_IMPLEMENTED
     Code
       stmt <- adbc_statement_init(con, key = "value")
     Output
       LogStatementNew()
       LogStatementSetOption()
+    Code
+      expect_identical(adbc_statement_get_option(stmt, "key"), "value")
+    Output
+      LogStatementGetOption()
+      LogStatementGetOption()
     Code
       try(adbc_statement_execute_query(stmt))
     Output
       LogStatementExecuteQuery()
       Error in adbc_statement_execute_query(stmt) : NOT_IMPLEMENTED
+    Code
+      try(adbc_statement_execute_schema(stmt))
+    Output
+      LogStatementExecuteSchema()
+      Error in adbc_statement_execute_schema(stmt) : NOT_IMPLEMENTED
+    Code
+      try(adbc_statement_prepare(stmt))
+    Output
+      LogStatementPrepare()
+      Error in adbc_statement_prepare(stmt) : NOT_IMPLEMENTED
+    Code
+      try(adbc_statement_set_sql_query(stmt, ""))
+    Output
+      LogStatementSetSqlQuery()
+      Error in adbc_statement_set_sql_query(stmt, "") : NOT_IMPLEMENTED
+    Code
+      try(adbc_statement_set_substrait_plan(stmt, raw()))
+    Output
+      LogStatementSetSubstraitPlan()
+      Error in adbc_statement_set_substrait_plan(stmt, raw()) : NOT_IMPLEMENTED
+    Code
+      try(adbc_statement_bind(stmt, data.frame()))
+    Output
+      LogStatementBind()
+      Error in adbc_statement_bind(stmt, data.frame()) : NOT_IMPLEMENTED
+    Code
+      try(adbc_statement_bind_stream(stmt, data.frame()))
+    Output
+      LogStatementBindStream()
+      Error in adbc_statement_bind_stream(stmt, data.frame()) : NOT_IMPLEMENTED
+    Code
+      try(adbc_statement_cancel(stmt))
+    Output
+      LogStatementCancel()
+      Error in adbc_statement_cancel(stmt) : NOT_IMPLEMENTED
     Code
       adbc_statement_release(stmt)
     Output
@@ -34,5 +136,4 @@
       adbc_database_release(db)
     Output
       LogDatabaseRelease()
-      LogDriverRelease()
 
diff --git a/r/adbcdrivermanager/tests/testthat/_snaps/helpers.md b/r/adbcdrivermanager/tests/testthat/_snaps/helpers.md
index 429b0fe8..2a729ff4 100644
--- a/r/adbcdrivermanager/tests/testthat/_snaps/helpers.md
+++ b/r/adbcdrivermanager/tests/testthat/_snaps/helpers.md
@@ -40,7 +40,6 @@
       adbc_database_release(db)
     Output
       LogDatabaseRelease()
-      LogDriverRelease()
 
 ---
 
@@ -84,7 +83,6 @@
       adbc_database_release(db)
     Output
       LogDatabaseRelease()
-      LogDriverRelease()
 
 # joiners work for databases, connections, and statements
 
@@ -111,5 +109,4 @@
       LogStatementRelease()
       LogConnectionRelease()
       LogDatabaseRelease()
-      LogDriverRelease()
 
diff --git a/r/adbcdrivermanager/tests/testthat/test-driver_log.R b/r/adbcdrivermanager/tests/testthat/test-driver_log.R
index 94704430..dd2e097e 100644
--- a/r/adbcdrivermanager/tests/testthat/test-driver_log.R
+++ b/r/adbcdrivermanager/tests/testthat/test-driver_log.R
@@ -18,9 +18,33 @@
 test_that("The log driver logs", {
   expect_snapshot({
     db <- adbc_database_init(adbc_driver_log(), key = "value")
+    expect_identical(adbc_database_get_option(db, "key"), "value")
+
     con <- adbc_connection_init(db, key = "value")
+    expect_identical(adbc_connection_get_option(con, "key"), "value")
+    try(adbc_connection_commit(con))
+    try(adbc_connection_get_info(con))
+    try(adbc_connection_get_objects(con))
+    try(adbc_connection_get_table_schema(con, NULL, NULL, "table_name"))
+    try(adbc_connection_get_table_types(con))
+    try(adbc_connection_read_partition(con, raw()))
+    try(adbc_connection_rollback(con))
+    try(adbc_connection_cancel(con))
+    try(adbc_connection_get_statistics(con, NULL, NULL, "table_name"))
+    try(adbc_connection_get_statistic_names(con))
+
     stmt <- adbc_statement_init(con, key = "value")
+    expect_identical(adbc_statement_get_option(stmt, "key"), "value")
+
     try(adbc_statement_execute_query(stmt))
+    try(adbc_statement_execute_schema(stmt))
+    try(adbc_statement_prepare(stmt))
+    try(adbc_statement_set_sql_query(stmt, ""))
+    try(adbc_statement_set_substrait_plan(stmt, raw()))
+    try(adbc_statement_bind(stmt, data.frame()))
+    try(adbc_statement_bind_stream(stmt, data.frame()))
+    try(adbc_statement_cancel(stmt))
+
     adbc_statement_release(stmt)
     adbc_connection_release(con)
     adbc_database_release(db)
diff --git a/r/adbcdrivermanager/tests/testthat/test-driver_monkey.R b/r/adbcdrivermanager/tests/testthat/test-driver_monkey.R
index ba587d11..d3ed532a 100644
--- a/r/adbcdrivermanager/tests/testthat/test-driver_monkey.R
+++ b/r/adbcdrivermanager/tests/testthat/test-driver_monkey.R
@@ -30,6 +30,6 @@ test_that("the monkey driver sees, and the monkey driver does", {
   adbc_statement_release(stmt)
 
   stmt <- adbc_statement_init(con, input)
-  expect_identical(adbc_statement_execute_query(stmt, NULL), 0)
+  expect_identical(adbc_statement_execute_query(stmt, NULL), -1)
   adbc_statement_release(stmt)
 })
diff --git a/r/adbcdrivermanager/tests/testthat/test-options.R b/r/adbcdrivermanager/tests/testthat/test-options.R
index 5e765b34..85ee78f7 100644
--- a/r/adbcdrivermanager/tests/testthat/test-options.R
+++ b/r/adbcdrivermanager/tests/testthat/test-options.R
@@ -32,7 +32,7 @@ test_that("get/set option can roundtrip string options for database", {
 test_that("get/set option can roundtrip bytes options for database", {
   db <- adbc_database_init(adbc_driver_void())
   expect_error(
-    adbc_database_get_option(db, "some_key"),
+    adbc_database_get_option_bytes(db, "some_key"),
     class = "adbc_status_not_found"
   )
 
@@ -47,7 +47,7 @@ test_that("get/set option can roundtrip integer options for database", {
   db <- adbc_database_init(adbc_driver_void())
 
   expect_error(
-    adbc_database_get_option(db, "some_key"),
+    adbc_database_get_option_int(db, "some_key"),
     class = "adbc_status_not_found"
   )
 
@@ -62,7 +62,7 @@ test_that("get/set option can roundtrip double options for database", {
   db <- adbc_database_init(adbc_driver_void())
 
   expect_error(
-    adbc_database_get_option(db, "some_key"),
+    adbc_database_get_option_double(db, "some_key"),
     class = "adbc_status_not_found"
   )
 
@@ -95,7 +95,7 @@ test_that("get/set option can roundtrip bytes options for connection", {
   con <- adbc_connection_init(db)
 
   expect_error(
-    adbc_connection_get_option(con, "some_key"),
+    adbc_connection_get_option_bytes(con, "some_key"),
     class = "adbc_status_not_found"
   )
 
@@ -111,7 +111,7 @@ test_that("get/set option can roundtrip int options for connection", {
   con <- adbc_connection_init(db)
 
   expect_error(
-    adbc_connection_get_option(con, "some_key"),
+    adbc_connection_get_option_int(con, "some_key"),
     class = "adbc_status_not_found"
   )
 
@@ -127,7 +127,7 @@ test_that("get/set option can roundtrip double options for connection", {
   con <- adbc_connection_init(db)
 
   expect_error(
-    adbc_connection_get_option(con, "some_key"),
+    adbc_connection_get_option_double(con, "some_key"),
     class = "adbc_status_not_found"
   )
 
@@ -161,7 +161,7 @@ test_that("get/set option can roundtrip bytes options for statement", {
   stmt <- adbc_statement_init(con)
 
   expect_error(
-    adbc_statement_get_option(stmt, "some_key"),
+    adbc_statement_get_option_bytes(stmt, "some_key"),
     class = "adbc_status_not_found"
   )
 
@@ -178,7 +178,7 @@ test_that("get/set option can roundtrip int options for statement", {
   stmt <- adbc_statement_init(con)
 
   expect_error(
-    adbc_statement_get_option(stmt, "some_key"),
+    adbc_statement_get_option_int(stmt, "some_key"),
     class = "adbc_status_not_found"
   )
 
@@ -195,7 +195,7 @@ test_that("get/set option can roundtrip double options for statement", {
   stmt <- adbc_statement_init(con)
 
   expect_error(
-    adbc_statement_get_option(stmt, "some_key"),
+    adbc_statement_get_option_double(stmt, "some_key"),
     class = "adbc_status_not_found"
   )
 
diff --git a/r/adbcdrivermanager/tests/testthat/test-radbc.R b/r/adbcdrivermanager/tests/testthat/test-radbc.R
index b332e711..18eab820 100644
--- a/r/adbcdrivermanager/tests/testthat/test-radbc.R
+++ b/r/adbcdrivermanager/tests/testthat/test-radbc.R
@@ -83,19 +83,19 @@ test_that("connection methods work for the void driver", {
     "NOT_IMPLEMENTED"
   )
 
-  expect_identical(
+  expect_error(
     adbc_connection_commit(con),
-    con
+    "NOT_IMPLEMENTED"
   )
 
-  expect_identical(
+  expect_error(
     adbc_connection_rollback(con),
-    con
+    "NOT_IMPLEMENTED"
   )
 
-  expect_identical(
+  expect_error(
     adbc_connection_cancel(con),
-    con
+    "NOT_IMPLEMENTED"
   )
 
   expect_error(
@@ -173,6 +173,11 @@ test_that("statement methods work for the void driver", {
     adbc_statement_execute_schema(stmt),
     "NOT_IMPLEMENTED"
   )
+
+  expect_error(
+    adbc_statement_cancel(stmt),
+    "NOT_IMPLEMENTED"
+  )
 })
 
 test_that("invalid external pointer inputs generate errors", {