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", {