You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by li...@apache.org on 2023/06/23 18:31:08 UTC
[arrow-adbc] branch spec-1.1.0 updated (f18f1cca -> 362638da)
This is an automated email from the ASF dual-hosted git repository.
lidavidm pushed a change to branch spec-1.1.0
in repository https://gitbox.apache.org/repos/asf/arrow-adbc.git
omit f18f1cca test(c): add backwards compatibility tests for 1.1.0/1.0.0 (#698)
omit b2f5395d feat(format): remove unnecessary padding (#731)
omit c09a6989 feat(format): introduce ADBC API revision 1.1.0 (#692)
add b3efd5a5 chore(r): Pin pkgbuild to work around bug in latest released version (#817)
add 20ef12b2 chore: update versions for 0.6.0-SNAPSHOT
add c53b1658 chore: update changelog for 0.5.0
add 9c7fe5dd fix(go/adbc/driver/snowflake): initialize Params, add DLL build (#820)
add 67bc05fd chore(dev/release): don't push to main in post-08-bump-versions (#822)
add 2f8a6a6e fix(csharp): submodule not pulling correctly (#824)
add 3112909c docs(go): Add Go install and usage examples (#826)
add 2f7fbdc6 refactor(csharp): cleanup load of imported drivers (#818)
add 17a13f9f feat(go/adbc/driver/flightsql): Add cookie middleware option (#825)
add f35485a5 fix(go/adbc/driver/snowflake): fix potential deadlock and error handling (#828)
add bb3b1601 feat(python/adbc_driver_flightsql): add cookie middleware option to DatabaseOptions (#830)
add 11fbbc13 chore(dev/release): fix file paths used in Windows wheel build (#832)
add 7548dcdc ci: Add CODEOWNERS file (#829)
add 2320ba9f chore(r/adbcdrivermanager): Add link in DESCRIPTION (#836)
add 997caa34 feat(r): Add FlightSQL driver wrapper (#835)
add 1999ae1e chore(dev/release): fix version bumper in Windows wheel build (#839)
add d5c7eada chore(r): Update + unify R driver packages after adbcdrivermanager CRAN release (#843)
new e266f168 feat(format): introduce ADBC API revision 1.1.0 (#692)
new 7f920bf7 feat(format): remove unnecessary padding (#731)
new 362638da test(c): add backwards compatibility tests for 1.1.0/1.0.0 (#698)
This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version. This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:
* -- * -- B -- O -- O -- O (f18f1cca)
\
N -- N -- N refs/heads/spec-1.1.0 (362638da)
You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.
Any revisions marked "omit" are not gone; other references still
refer to them. Any revisions marked "discard" are gone forever.
The 3 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.github/CODEOWNERS | 54 ++++++++
.github/workflows/native-unix.yml | 19 ++-
csharp/.gitmodules => .gitmodules | 7 +-
CHANGELOG.md | 64 +++++++++
c/cmake_modules/AdbcVersion.cmake | 2 +-
ci/conda/meta.yaml | 2 +-
ci/linux-packages/debian/control | 22 +--
...install => libadbc-driver-flightsql006.install} | 0
...5.install => libadbc-driver-manager006.install} | 0
...nstall => libadbc-driver-postgresql006.install} | 0
...install => libadbc-driver-snowflake006.install} | 0
...05.install => libadbc-driver-sqlite006.install} | 0
ci/scripts/python_wheel_windows_build.bat | 12 +-
.../src/Apache.Arrow.Adbc/Apache.Arrow.Adbc.csproj | 6 +-
.../src/Apache.Arrow.Adbc/C/CAdbcDriverImporter.cs | 144 +++++++------------
csharp/src/Apache.Arrow.Adbc/C/NativeLibrary.cs | 102 ++++++++++++++
dev/release/post-08-bump-versions.sh | 5 +-
dev/release/rat_exclude_files.txt | 26 +---
dev/release/utils-prepare.sh | 4 +
docs/source/conf.py | 2 +-
docs/source/driver/flight_sql.rst | 53 ++++++-
docs/source/driver/postgresql.rst | 38 +++++-
docs/source/driver/snowflake.rst | 29 +++-
docs/source/driver/sqlite.rst | 45 +++++-
glib/meson.build | 2 +-
go/adbc/driver/flightsql/flightsql_adbc.go | 33 ++++-
.../driver/flightsql/flightsql_adbc_server_test.go | 152 +++++++++++++++++----
go/adbc/driver/flightsql/record_reader.go | 4 +
go/adbc/driver/snowflake/driver.go | 9 +-
go/adbc/driver/snowflake/record_reader.go | 59 ++++----
go/adbc/go.mod | 22 ++-
go/adbc/go.sum | 44 +++---
go/adbc/pkg/Makefile | 2 +
java/core/pom.xml | 2 +-
java/driver-manager/pom.xml | 2 +-
java/driver/flight-sql-validation/pom.xml | 2 +-
java/driver/flight-sql/pom.xml | 2 +-
java/driver/jdbc-validation-derby/pom.xml | 2 +-
java/driver/jdbc-validation-mssqlserver/pom.xml | 2 +-
java/driver/jdbc-validation-postgresql/pom.xml | 2 +-
java/driver/jdbc/pom.xml | 2 +-
java/driver/validation/pom.xml | 2 +-
java/pom.xml | 4 +-
java/sql/pom.xml | 2 +-
.../adbc_driver_flightsql/__init__.py | 2 +
r/adbcdrivermanager/DESCRIPTION | 6 +-
r/adbcdrivermanager/README.Rmd | 2 +-
r/adbcdrivermanager/README.md | 2 +-
.../man/adbcdrivermanager-package.Rd | 2 +-
r/{adbcsnowflake => adbcflightsql}/.Rbuildignore | 2 +-
r/{adbcpostgresql => adbcflightsql}/.gitignore | 0
r/{adbcdrivermanager => adbcflightsql}/DESCRIPTION | 23 ++--
r/{adbcdrivermanager => adbcflightsql}/LICENSE.md | 0
r/adbcflightsql/NAMESPACE | 10 ++
.../R/adbcflightsql-package.R} | 36 ++---
r/{adbcsqlite => adbcflightsql}/README.Rmd | 50 +++----
.../README.Rmd => adbcflightsql/README.md} | 73 +++++-----
.../adbcflightsql.Rproj} | 0
r/{adbcsnowflake => adbcflightsql}/bootstrap.R | 0
r/{adbcsnowflake => adbcflightsql}/cleanup | 0
r/{adbcpostgresql => adbcflightsql}/cleanup.win | 0
r/{adbcsnowflake => adbcflightsql}/configure | 10 +-
r/{adbcpostgresql => adbcflightsql}/configure.win | 0
.../man/adbcflightsql-package.Rd} | 10 +-
.../man/adbcflightsql.Rd} | 26 ++--
r/{adbcsnowflake => adbcflightsql}/src/.gitignore | 0
r/{adbcsnowflake => adbcflightsql}/src/Makevars.in | 4 +-
.../src/Makevars.win | 4 +-
.../src/go/.gitignore | 4 +-
.../src/go/symbols.map | 4 +-
r/{adbcsnowflake => adbcflightsql}/src/init.c | 6 +-
.../tests/testthat.R | 4 +-
.../tests/testthat/test-adbcflightsql-package.R} | 20 +--
.../tools/download-go.R | 0
r/adbcpostgresql/DESCRIPTION | 19 +--
r/adbcpostgresql/R/adbcpostgresql-package.R | 9 +-
r/adbcpostgresql/README.Rmd | 32 ++---
r/adbcpostgresql/README.md | 63 ++++-----
r/adbcpostgresql/man/adbcpostgresql-package.Rd | 9 +-
r/adbcsnowflake/DESCRIPTION | 19 +--
r/adbcsnowflake/R/adbcsnowflake-package.R | 6 +-
r/adbcsnowflake/README.Rmd | 14 +-
r/adbcsnowflake/README.md | 14 +-
r/adbcsnowflake/man/adbcsnowflake-package.Rd | 9 +-
r/adbcsqlite/DESCRIPTION | 19 +--
r/adbcsqlite/R/adbcsqlite-package.R | 9 +-
r/adbcsqlite/README.Rmd | 24 ++--
r/adbcsqlite/README.md | 58 ++++----
r/adbcsqlite/man/adbcsqlite-package.Rd | 9 +-
ruby/lib/adbc/version.rb | 2 +-
rust/Cargo.toml | 2 +-
91 files changed, 1026 insertions(+), 578 deletions(-)
create mode 100644 .github/CODEOWNERS
rename csharp/.gitmodules => .gitmodules (88%)
rename ci/linux-packages/debian/{libadbc-driver-flightsql005.install => libadbc-driver-flightsql006.install} (100%)
rename ci/linux-packages/debian/{libadbc-driver-manager005.install => libadbc-driver-manager006.install} (100%)
rename ci/linux-packages/debian/{libadbc-driver-postgresql005.install => libadbc-driver-postgresql006.install} (100%)
rename ci/linux-packages/debian/{libadbc-driver-snowflake005.install => libadbc-driver-snowflake006.install} (100%)
rename ci/linux-packages/debian/{libadbc-driver-sqlite005.install => libadbc-driver-sqlite006.install} (100%)
create mode 100644 csharp/src/Apache.Arrow.Adbc/C/NativeLibrary.cs
copy r/{adbcsnowflake => adbcflightsql}/.Rbuildignore (83%)
copy r/{adbcpostgresql => adbcflightsql}/.gitignore (100%)
copy r/{adbcdrivermanager => adbcflightsql}/DESCRIPTION (53%)
copy r/{adbcdrivermanager => adbcflightsql}/LICENSE.md (100%)
create mode 100644 r/adbcflightsql/NAMESPACE
copy r/{adbcsnowflake/R/adbcsnowflake-package.R => adbcflightsql/R/adbcflightsql-package.R} (77%)
copy r/{adbcsqlite => adbcflightsql}/README.Rmd (58%)
copy r/{adbcsqlite/README.Rmd => adbcflightsql/README.md} (50%)
copy r/{adbcdrivermanager/adbcdrivermanager.Rproj => adbcflightsql/adbcflightsql.Rproj} (100%)
copy r/{adbcsnowflake => adbcflightsql}/bootstrap.R (100%)
copy r/{adbcsnowflake => adbcflightsql}/cleanup (100%)
copy r/{adbcpostgresql => adbcflightsql}/cleanup.win (100%)
copy r/{adbcsnowflake => adbcflightsql}/configure (90%)
copy r/{adbcpostgresql => adbcflightsql}/configure.win (100%)
copy r/{adbcdrivermanager/man/adbcdrivermanager-package.Rd => adbcflightsql/man/adbcflightsql-package.Rd} (52%)
copy r/{adbcsnowflake/man/adbcsnowflake.Rd => adbcflightsql/man/adbcflightsql.Rd} (65%)
copy r/{adbcsnowflake => adbcflightsql}/src/.gitignore (100%)
copy r/{adbcsnowflake => adbcflightsql}/src/Makevars.in (89%)
copy r/{adbcsnowflake => adbcflightsql}/src/Makevars.win (91%)
copy r/{adbcsnowflake => adbcflightsql}/src/go/.gitignore (93%)
copy r/{adbcsnowflake => adbcflightsql}/src/go/symbols.map (93%)
copy r/{adbcsnowflake => adbcflightsql}/src/init.c (88%)
copy r/{adbcsnowflake => adbcflightsql}/tests/testthat.R (95%)
copy r/{adbcpostgresql/tests/testthat/test-adbcpostgres-package.R => adbcflightsql/tests/testthat/test-adbcflightsql-package.R} (83%)
copy r/{adbcsnowflake => adbcflightsql}/tools/download-go.R (100%)
[arrow-adbc] 03/03: test(c): add backwards compatibility tests for 1.1.0/1.0.0 (#698)
Posted by li...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
lidavidm pushed a commit to branch spec-1.1.0
in repository https://gitbox.apache.org/repos/asf/arrow-adbc.git
commit 362638da63d164c9781c355ae156bf07979ed301
Author: David Li <li...@gmail.com>
AuthorDate: Tue Jun 6 16:09:43 2023 -0400
test(c): add backwards compatibility tests for 1.1.0/1.0.0 (#698)
Requires #692.
---
c/driver_manager/CMakeLists.txt | 16 +
c/driver_manager/adbc_driver_manager.cc | 370 ++++++++++++++++++++-
c/driver_manager/adbc_driver_manager_test.cc | 32 --
c/driver_manager/adbc_version_100.c | 117 +++++++
c/driver_manager/adbc_version_100.h | 87 +++++
.../adbc_version_100_compatibility_test.cc | 103 ++++++
6 files changed, 678 insertions(+), 47 deletions(-)
diff --git a/c/driver_manager/CMakeLists.txt b/c/driver_manager/CMakeLists.txt
index dd28470c..637843ff 100644
--- a/c/driver_manager/CMakeLists.txt
+++ b/c/driver_manager/CMakeLists.txt
@@ -64,4 +64,20 @@ if(ADBC_BUILD_TESTS)
target_compile_features(adbc-driver-manager-test PRIVATE cxx_std_17)
target_include_directories(adbc-driver-manager-test SYSTEM
PRIVATE ${REPOSITORY_ROOT}/c/vendor/nanoarrow/)
+
+ add_test_case(version_100_compatibility_test
+ PREFIX
+ adbc
+ EXTRA_LABELS
+ driver-manager
+ SOURCES
+ adbc_version_100.c
+ adbc_version_100_compatibility_test.cc
+ ../validation/adbc_validation_util.cc
+ EXTRA_LINK_LIBS
+ nanoarrow
+ ${TEST_LINK_LIBS})
+ target_compile_features(adbc-version-100-compatibility-test PRIVATE cxx_std_17)
+ target_include_directories(adbc-version-100-compatibility-test SYSTEM
+ PRIVATE ${REPOSITORY_ROOT}/c/vendor/nanoarrow/)
endif()
diff --git a/c/driver_manager/adbc_driver_manager.cc b/c/driver_manager/adbc_driver_manager.cc
index 4ad77f2e..e0315d86 100644
--- a/c/driver_manager/adbc_driver_manager.cc
+++ b/c/driver_manager/adbc_driver_manager.cc
@@ -130,11 +130,36 @@ static AdbcStatusCode ReleaseDriver(struct AdbcDriver* driver, struct AdbcError*
// Default stubs
+AdbcStatusCode DatabaseGetOption(struct AdbcDatabase* database, const char* key,
+ const char** value, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
+AdbcStatusCode DatabaseGetOptionInt(struct AdbcDatabase* database, const char* key,
+ int64_t* value, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
+AdbcStatusCode DatabaseGetOptionDouble(struct AdbcDatabase* database, const char* key,
+ double* value, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
AdbcStatusCode DatabaseSetOption(struct AdbcDatabase* database, const char* key,
const char* value, struct AdbcError* error) {
return ADBC_STATUS_NOT_IMPLEMENTED;
}
+AdbcStatusCode DatabaseSetOptionInt(struct AdbcDatabase* database, const char* key,
+ int64_t value, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
+AdbcStatusCode DatabaseSetOptionDouble(struct AdbcDatabase* database, const char* key,
+ double value, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
AdbcStatusCode ConnectionCommit(struct AdbcConnection*, struct AdbcError* error) {
return ADBC_STATUS_NOT_IMPLEMENTED;
}
@@ -151,6 +176,22 @@ AdbcStatusCode ConnectionGetObjects(struct AdbcConnection*, int, const char*, co
return ADBC_STATUS_NOT_IMPLEMENTED;
}
+AdbcStatusCode ConnectionGetOption(struct AdbcConnection* connection, const char* key,
+ const char** value, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
+AdbcStatusCode ConnectionGetOptionInt(struct AdbcConnection* connection, const char* key,
+ int64_t* value, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
+AdbcStatusCode ConnectionGetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double* value,
+ struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
AdbcStatusCode ConnectionGetTableSchema(struct AdbcConnection*, const char*, const char*,
const char*, struct ArrowSchema*,
struct AdbcError* error) {
@@ -179,11 +220,26 @@ AdbcStatusCode ConnectionSetOption(struct AdbcConnection*, const char*, const ch
return ADBC_STATUS_NOT_IMPLEMENTED;
}
+AdbcStatusCode ConnectionSetOptionInt(struct AdbcConnection* connection, const char* key,
+ int64_t value, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
+AdbcStatusCode ConnectionSetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double value,
+ struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
AdbcStatusCode StatementBind(struct AdbcStatement*, struct ArrowArray*,
struct ArrowSchema*, struct AdbcError* error) {
return ADBC_STATUS_NOT_IMPLEMENTED;
}
+AdbcStatusCode StatementCancel(struct AdbcStatement* statement, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
AdbcStatusCode StatementExecutePartitions(struct AdbcStatement* statement,
struct ArrowSchema* schema,
struct AdbcPartitions* partitions,
@@ -198,6 +254,21 @@ AdbcStatusCode StatementExecuteSchema(struct AdbcStatement* statement,
return ADBC_STATUS_NOT_IMPLEMENTED;
}
+AdbcStatusCode StatementGetOption(struct AdbcStatement* statement, const char* key,
+ const char** value, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
+AdbcStatusCode StatementGetOptionInt(struct AdbcStatement* statement, const char* key,
+ int64_t* value, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
+AdbcStatusCode StatementGetOptionDouble(struct AdbcStatement* statement, const char* key,
+ double* value, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
AdbcStatusCode StatementGetParameterSchema(struct AdbcStatement* statement,
struct ArrowSchema* schema,
struct AdbcError* error) {
@@ -213,6 +284,16 @@ AdbcStatusCode StatementSetOption(struct AdbcStatement*, const char*, const char
return ADBC_STATUS_NOT_IMPLEMENTED;
}
+AdbcStatusCode StatementSetOptionInt(struct AdbcStatement* statement, const char* key,
+ int64_t value, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
+AdbcStatusCode StatementSetOptionDouble(struct AdbcStatement* statement, const char* key,
+ double value, struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
AdbcStatusCode StatementSetSqlQuery(struct AdbcStatement*, const char*,
struct AdbcError* error) {
return ADBC_STATUS_NOT_IMPLEMENTED;
@@ -226,6 +307,8 @@ AdbcStatusCode StatementSetSubstraitPlan(struct AdbcStatement*, const uint8_t*,
/// Temporary state while the database is being configured.
struct TempDatabase {
std::unordered_map<std::string, std::string> options;
+ std::unordered_map<std::string, int64_t> int_options;
+ std::unordered_map<std::string, double> double_options;
std::string driver;
// Default name (see adbc.h)
std::string entrypoint = "AdbcDriverInit";
@@ -235,6 +318,8 @@ struct TempDatabase {
/// Temporary state while the database is being configured.
struct TempConnection {
std::unordered_map<std::string, std::string> options;
+ std::unordered_map<std::string, int64_t> int_options;
+ std::unordered_map<std::string, double> double_options;
};
} // namespace
@@ -247,6 +332,54 @@ AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase* database, struct AdbcError*
return ADBC_STATUS_OK;
}
+AdbcStatusCode AdbcDatabaseGetOption(struct AdbcDatabase* database, const char* key,
+ const char** value, struct AdbcError* error) {
+ if (database->private_driver) {
+ return database->private_driver->DatabaseGetOption(database, key, value, error);
+ }
+ const auto* args = reinterpret_cast<const TempDatabase*>(database->private_data);
+ if (std::strcmp(key, "driver") == 0) {
+ *value = args->driver.c_str();
+ } else if (std::strcmp(key, "entrypoint") == 0) {
+ *value = args->entrypoint.c_str();
+ } else {
+ const auto it = args->options.find(key);
+ if (it == args->options.end()) {
+ return ADBC_STATUS_NOT_FOUND;
+ }
+ *value = it->second.c_str();
+ }
+ return ADBC_STATUS_OK;
+}
+
+AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase* database, const char* key,
+ int64_t* value, struct AdbcError* error) {
+ if (database->private_driver) {
+ return database->private_driver->DatabaseGetOptionInt(database, key, value, error);
+ }
+ const auto* args = reinterpret_cast<const TempDatabase*>(database->private_data);
+ const auto it = args->int_options.find(key);
+ if (it == args->int_options.end()) {
+ return ADBC_STATUS_NOT_FOUND;
+ }
+ *value = it->second;
+ return ADBC_STATUS_OK;
+}
+
+AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase* database, const char* key,
+ double* value, struct AdbcError* error) {
+ if (database->private_driver) {
+ return database->private_driver->DatabaseGetOptionDouble(database, key, value, error);
+ }
+ const auto* args = reinterpret_cast<const TempDatabase*>(database->private_data);
+ const auto it = args->double_options.find(key);
+ if (it == args->double_options.end()) {
+ return ADBC_STATUS_NOT_FOUND;
+ }
+ *value = it->second;
+ return ADBC_STATUS_OK;
+}
+
AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase* database, const char* key,
const char* value, struct AdbcError* error) {
if (database->private_driver) {
@@ -264,6 +397,28 @@ AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase* database, const char*
return ADBC_STATUS_OK;
}
+AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase* database, const char* key,
+ int64_t value, struct AdbcError* error) {
+ if (database->private_driver) {
+ return database->private_driver->DatabaseSetOptionInt(database, key, value, error);
+ }
+
+ TempDatabase* args = reinterpret_cast<TempDatabase*>(database->private_data);
+ args->int_options[key] = value;
+ return ADBC_STATUS_OK;
+}
+
+AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase* database, const char* key,
+ double value, struct AdbcError* error) {
+ if (database->private_driver) {
+ return database->private_driver->DatabaseSetOptionDouble(database, key, value, error);
+ }
+
+ TempDatabase* args = reinterpret_cast<TempDatabase*>(database->private_data);
+ args->double_options[key] = value;
+ return ADBC_STATUS_OK;
+}
+
AdbcStatusCode AdbcDriverManagerDatabaseSetInitFunc(struct AdbcDatabase* database,
AdbcDriverInitFunc init_func,
struct AdbcError* error) {
@@ -320,25 +475,40 @@ AdbcStatusCode AdbcDatabaseInit(struct AdbcDatabase* database, struct AdbcError*
database->private_driver = nullptr;
return status;
}
- for (const auto& option : args->options) {
+ auto options = std::move(args->options);
+ auto int_options = std::move(args->int_options);
+ auto double_options = std::move(args->double_options);
+ delete args;
+
+ for (const auto& option : options) {
status = database->private_driver->DatabaseSetOption(database, option.first.c_str(),
option.second.c_str(), error);
- if (status != ADBC_STATUS_OK) {
- delete args;
- // Release the database
- std::ignore = database->private_driver->DatabaseRelease(database, error);
- if (database->private_driver->release) {
- database->private_driver->release(database->private_driver, error);
- }
- delete database->private_driver;
- database->private_driver = nullptr;
- // Should be redundant, but ensure that AdbcDatabaseRelease
- // below doesn't think that it contains a TempDatabase
- database->private_data = nullptr;
- return status;
+ if (status != ADBC_STATUS_OK) break;
+ }
+ for (const auto& option : int_options) {
+ status = database->private_driver->DatabaseSetOptionInt(
+ database, option.first.c_str(), option.second, error);
+ if (status != ADBC_STATUS_OK) break;
+ }
+ for (const auto& option : double_options) {
+ status = database->private_driver->DatabaseSetOptionDouble(
+ database, option.first.c_str(), option.second, error);
+ if (status != ADBC_STATUS_OK) break;
+ }
+
+ if (status != ADBC_STATUS_OK) {
+ // Release the database
+ std::ignore = database->private_driver->DatabaseRelease(database, error);
+ if (database->private_driver->release) {
+ database->private_driver->release(database->private_driver, error);
}
+ delete database->private_driver;
+ database->private_driver = nullptr;
+ // Should be redundant, but ensure that AdbcDatabaseRelease
+ // below doesn't think that it contains a TempDatabase
+ database->private_data = nullptr;
+ return status;
}
- delete args;
return database->private_driver->DatabaseInit(database, error);
}
@@ -396,6 +566,67 @@ AdbcStatusCode AdbcConnectionGetObjects(struct AdbcConnection* connection, int d
error);
}
+AdbcStatusCode AdbcConnectionGetOption(struct AdbcConnection* connection, const char* key,
+ const char** value, struct AdbcError* error) {
+ if (!connection->private_data) {
+ SetError(error, "AdbcConnectionGetOption: must AdbcConnectionNew first");
+ return ADBC_STATUS_INVALID_STATE;
+ }
+ if (!connection->private_driver) {
+ // Init not yet called, get the saved option
+ const auto* args = reinterpret_cast<const TempConnection*>(connection->private_data);
+ const auto it = args->options.find(key);
+ if (it == args->options.end()) {
+ return ADBC_STATUS_NOT_FOUND;
+ }
+ *value = it->second.c_str();
+ return ADBC_STATUS_OK;
+ }
+ return connection->private_driver->ConnectionGetOption(connection, key, value, error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionInt(struct AdbcConnection* connection,
+ const char* key, int64_t* value,
+ struct AdbcError* error) {
+ if (!connection->private_data) {
+ SetError(error, "AdbcConnectionGetOption: must AdbcConnectionNew first");
+ return ADBC_STATUS_INVALID_STATE;
+ }
+ if (!connection->private_driver) {
+ // Init not yet called, get the saved option
+ const auto* args = reinterpret_cast<const TempConnection*>(connection->private_data);
+ const auto it = args->int_options.find(key);
+ if (it == args->int_options.end()) {
+ return ADBC_STATUS_NOT_FOUND;
+ }
+ *value = it->second;
+ return ADBC_STATUS_OK;
+ }
+ return connection->private_driver->ConnectionGetOptionInt(connection, key, value,
+ error);
+}
+
+AdbcStatusCode AdbcConnectionGetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double* value,
+ struct AdbcError* error) {
+ if (!connection->private_data) {
+ SetError(error, "AdbcConnectionGetOption: must AdbcConnectionNew first");
+ return ADBC_STATUS_INVALID_STATE;
+ }
+ if (!connection->private_driver) {
+ // Init not yet called, get the saved option
+ const auto* args = reinterpret_cast<const TempConnection*>(connection->private_data);
+ const auto it = args->double_options.find(key);
+ if (it == args->double_options.end()) {
+ return ADBC_STATUS_NOT_FOUND;
+ }
+ *value = it->second;
+ return ADBC_STATUS_OK;
+ }
+ return connection->private_driver->ConnectionGetOptionDouble(connection, key, value,
+ error);
+}
+
AdbcStatusCode AdbcConnectionGetTableSchema(struct AdbcConnection* connection,
const char* catalog, const char* db_schema,
const char* table_name,
@@ -430,6 +661,9 @@ AdbcStatusCode AdbcConnectionInit(struct AdbcConnection* connection,
TempConnection* args = reinterpret_cast<TempConnection*>(connection->private_data);
connection->private_data = nullptr;
std::unordered_map<std::string, std::string> options = std::move(args->options);
+ std::unordered_map<std::string, int64_t> int_options = std::move(args->int_options);
+ std::unordered_map<std::string, double> double_options =
+ std::move(args->double_options);
delete args;
auto status = database->private_driver->ConnectionNew(connection, error);
@@ -441,6 +675,16 @@ AdbcStatusCode AdbcConnectionInit(struct AdbcConnection* connection,
connection, option.first.c_str(), option.second.c_str(), error);
if (status != ADBC_STATUS_OK) return status;
}
+ for (const auto& option : int_options) {
+ status = database->private_driver->ConnectionSetOptionInt(
+ connection, option.first.c_str(), option.second, error);
+ if (status != ADBC_STATUS_OK) return status;
+ }
+ for (const auto& option : double_options) {
+ status = database->private_driver->ConnectionSetOptionDouble(
+ connection, option.first.c_str(), option.second, error);
+ if (status != ADBC_STATUS_OK) return status;
+ }
return connection->private_driver->ConnectionInit(connection, database, error);
}
@@ -505,6 +749,40 @@ AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection* connection, const
return connection->private_driver->ConnectionSetOption(connection, key, value, error);
}
+AdbcStatusCode AdbcConnectionSetOptionInt(struct AdbcConnection* connection,
+ const char* key, int64_t value,
+ struct AdbcError* error) {
+ if (!connection->private_data) {
+ SetError(error, "AdbcConnectionSetOptionInt: must AdbcConnectionNew first");
+ return ADBC_STATUS_INVALID_STATE;
+ }
+ if (!connection->private_driver) {
+ // Init not yet called, save the option
+ TempConnection* args = reinterpret_cast<TempConnection*>(connection->private_data);
+ args->int_options[key] = value;
+ return ADBC_STATUS_OK;
+ }
+ return connection->private_driver->ConnectionSetOptionInt(connection, key, value,
+ error);
+}
+
+AdbcStatusCode AdbcConnectionSetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double value,
+ struct AdbcError* error) {
+ if (!connection->private_data) {
+ SetError(error, "AdbcConnectionSetOptionDouble: must AdbcConnectionNew first");
+ return ADBC_STATUS_INVALID_STATE;
+ }
+ if (!connection->private_driver) {
+ // Init not yet called, save the option
+ TempConnection* args = reinterpret_cast<TempConnection*>(connection->private_data);
+ args->double_options[key] = value;
+ return ADBC_STATUS_OK;
+ }
+ return connection->private_driver->ConnectionSetOptionDouble(connection, key, value,
+ error);
+}
+
AdbcStatusCode AdbcStatementBind(struct AdbcStatement* statement,
struct ArrowArray* values, struct ArrowSchema* schema,
struct AdbcError* error) {
@@ -556,6 +834,32 @@ AdbcStatusCode AdbcStatementExecuteSchema(struct AdbcStatement* statement,
return statement->private_driver->StatementExecuteSchema(statement, schema, error);
}
+AdbcStatusCode AdbcStatementGetOption(struct AdbcStatement* statement, const char* key,
+ const char** value, struct AdbcError* error) {
+ if (!statement->private_driver) {
+ return ADBC_STATUS_INVALID_STATE;
+ }
+ return statement->private_driver->StatementGetOption(statement, key, value, error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionInt(struct AdbcStatement* statement, const char* key,
+ int64_t* value, struct AdbcError* error) {
+ if (!statement->private_driver) {
+ return ADBC_STATUS_INVALID_STATE;
+ }
+ return statement->private_driver->StatementGetOptionInt(statement, key, value, error);
+}
+
+AdbcStatusCode AdbcStatementGetOptionDouble(struct AdbcStatement* statement,
+ const char* key, double* value,
+ struct AdbcError* error) {
+ if (!statement->private_driver) {
+ return ADBC_STATUS_INVALID_STATE;
+ }
+ return statement->private_driver->StatementGetOptionDouble(statement, key, value,
+ error);
+}
+
AdbcStatusCode AdbcStatementGetParameterSchema(struct AdbcStatement* statement,
struct ArrowSchema* schema,
struct AdbcError* error) {
@@ -602,6 +906,24 @@ AdbcStatusCode AdbcStatementSetOption(struct AdbcStatement* statement, const cha
return statement->private_driver->StatementSetOption(statement, key, value, error);
}
+AdbcStatusCode AdbcStatementSetOptionInt(struct AdbcStatement* statement, const char* key,
+ int64_t value, struct AdbcError* error) {
+ if (!statement->private_driver) {
+ return ADBC_STATUS_INVALID_STATE;
+ }
+ return statement->private_driver->StatementSetOptionInt(statement, key, value, error);
+}
+
+AdbcStatusCode AdbcStatementSetOptionDouble(struct AdbcStatement* statement,
+ const char* key, double value,
+ struct AdbcError* error) {
+ if (!statement->private_driver) {
+ return ADBC_STATUS_INVALID_STATE;
+ }
+ return statement->private_driver->StatementSetOptionDouble(statement, key, value,
+ error);
+}
+
AdbcStatusCode AdbcStatementSetSqlQuery(struct AdbcStatement* statement,
const char* query, struct AdbcError* error) {
if (!statement->private_driver) {
@@ -869,7 +1191,25 @@ AdbcStatusCode AdbcLoadDriverFromInitFunc(AdbcDriverInitFunc init_func, int vers
}
if (version >= ADBC_VERSION_1_1_0) {
auto* driver = reinterpret_cast<struct AdbcDriver*>(raw_driver);
+ FILL_DEFAULT(driver, DatabaseGetOption);
+ FILL_DEFAULT(driver, DatabaseGetOptionInt);
+ FILL_DEFAULT(driver, DatabaseGetOptionDouble);
+ FILL_DEFAULT(driver, DatabaseSetOptionInt);
+ FILL_DEFAULT(driver, DatabaseSetOptionDouble);
+
+ FILL_DEFAULT(driver, ConnectionGetOption);
+ FILL_DEFAULT(driver, ConnectionGetOptionInt);
+ FILL_DEFAULT(driver, ConnectionGetOptionDouble);
+ FILL_DEFAULT(driver, ConnectionSetOptionInt);
+ FILL_DEFAULT(driver, ConnectionSetOptionDouble);
+
+ FILL_DEFAULT(driver, StatementCancel);
FILL_DEFAULT(driver, StatementExecuteSchema);
+ FILL_DEFAULT(driver, StatementGetOption);
+ FILL_DEFAULT(driver, StatementGetOptionInt);
+ FILL_DEFAULT(driver, StatementGetOptionDouble);
+ FILL_DEFAULT(driver, StatementSetOptionInt);
+ FILL_DEFAULT(driver, StatementSetOptionDouble);
}
return ADBC_STATUS_OK;
diff --git a/c/driver_manager/adbc_driver_manager_test.cc b/c/driver_manager/adbc_driver_manager_test.cc
index 97743e70..99fa477b 100644
--- a/c/driver_manager/adbc_driver_manager_test.cc
+++ b/c/driver_manager/adbc_driver_manager_test.cc
@@ -157,38 +157,6 @@ TEST_F(DriverManager, MultiDriverTest) {
error->release(&error.value);
}
-class AdbcVersion : public ::testing::Test {
- public:
- void SetUp() override {
- std::memset(&driver, 0, sizeof(driver));
- std::memset(&error, 0, sizeof(error));
- }
-
- void TearDown() override {
- if (error.release) {
- error.release(&error);
- }
-
- if (driver.release) {
- ASSERT_THAT(driver.release(&driver, &error), IsOkStatus(&error));
- ASSERT_EQ(driver.private_data, nullptr);
- ASSERT_EQ(driver.private_manager, nullptr);
- }
- }
-
- protected:
- struct AdbcDriver driver = {};
- struct AdbcError error = {};
-};
-
-// TODO: set up a dummy driver to test behavior more deterministically
-
-TEST_F(AdbcVersion, ForwardsCompatible) {
- ASSERT_THAT(
- AdbcLoadDriver("adbc_driver_sqlite", nullptr, ADBC_VERSION_1_1_0, &driver, &error),
- IsOkStatus(&error));
-}
-
class SqliteQuirks : public adbc_validation::DriverQuirks {
public:
AdbcStatusCode SetupDatabase(struct AdbcDatabase* database,
diff --git a/c/driver_manager/adbc_version_100.c b/c/driver_manager/adbc_version_100.c
new file mode 100644
index 00000000..48114cdb
--- /dev/null
+++ b/c/driver_manager/adbc_version_100.c
@@ -0,0 +1,117 @@
+// 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.
+
+#include "adbc_version_100.h"
+
+#include <string.h>
+
+struct Version100Database {
+ int dummy;
+};
+
+static struct Version100Database kDatabase;
+
+struct Version100Connection {
+ int dummy;
+};
+
+static struct Version100Connection kConnection;
+
+struct Version100Statement {
+ int dummy;
+};
+
+static struct Version100Statement kStatement;
+
+AdbcStatusCode Version100DatabaseInit(struct AdbcDatabase* database,
+ struct AdbcError* error) {
+ return ADBC_STATUS_OK;
+}
+
+AdbcStatusCode Version100DatabaseNew(struct AdbcDatabase* database,
+ struct AdbcError* error) {
+ database->private_data = &kDatabase;
+ return ADBC_STATUS_OK;
+}
+
+AdbcStatusCode Version100DatabaseRelease(struct AdbcDatabase* database,
+ struct AdbcError* error) {
+ database->private_data = NULL;
+ return ADBC_STATUS_OK;
+}
+
+AdbcStatusCode Version100ConnectionInit(struct AdbcConnection* connection,
+ struct AdbcDatabase* database,
+ struct AdbcError* error) {
+ return ADBC_STATUS_OK;
+}
+
+AdbcStatusCode Version100ConnectionNew(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ connection->private_data = &kConnection;
+ return ADBC_STATUS_OK;
+}
+
+AdbcStatusCode Version100StatementExecuteQuery(struct AdbcStatement* statement,
+ struct ArrowArrayStream* stream,
+ int64_t* rows_affected,
+ struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
+AdbcStatusCode Version100StatementNew(struct AdbcConnection* connection,
+ struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ statement->private_data = &kStatement;
+ return ADBC_STATUS_OK;
+}
+
+AdbcStatusCode Version100StatementRelease(struct AdbcStatement* statement,
+ struct AdbcError* error) {
+ statement->private_data = NULL;
+ return ADBC_STATUS_OK;
+}
+
+AdbcStatusCode Version100ConnectionRelease(struct AdbcConnection* connection,
+ struct AdbcError* error) {
+ connection->private_data = NULL;
+ return ADBC_STATUS_OK;
+}
+
+AdbcStatusCode Version100DriverInit(int version, void* raw_driver,
+ struct AdbcError* error) {
+ if (version != ADBC_VERSION_1_0_0) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+ }
+
+ struct AdbcDriverVersion100* driver = (struct AdbcDriverVersion100*)raw_driver;
+ memset(driver, 0, sizeof(struct AdbcDriverVersion100));
+
+ driver->DatabaseInit = &Version100DatabaseInit;
+ driver->DatabaseNew = &Version100DatabaseNew;
+ driver->DatabaseRelease = &Version100DatabaseRelease;
+
+ driver->ConnectionInit = &Version100ConnectionInit;
+ driver->ConnectionNew = &Version100ConnectionNew;
+ driver->ConnectionRelease = &Version100ConnectionRelease;
+
+ driver->StatementExecuteQuery = &Version100StatementExecuteQuery;
+ driver->StatementNew = &Version100StatementNew;
+ driver->StatementRelease = &Version100StatementRelease;
+
+ return ADBC_STATUS_OK;
+}
diff --git a/c/driver_manager/adbc_version_100.h b/c/driver_manager/adbc_version_100.h
new file mode 100644
index 00000000..b4a8b949
--- /dev/null
+++ b/c/driver_manager/adbc_version_100.h
@@ -0,0 +1,87 @@
+// 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.
+
+// A dummy version 1.0.0 ADBC driver to test compatibility.
+
+#include <adbc.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct AdbcDriverVersion100 {
+ void* private_data;
+ void* private_manager;
+ AdbcStatusCode (*release)(struct AdbcDriver* driver, struct AdbcError* error);
+
+ AdbcStatusCode (*DatabaseInit)(struct AdbcDatabase*, struct AdbcError*);
+ AdbcStatusCode (*DatabaseNew)(struct AdbcDatabase*, struct AdbcError*);
+ AdbcStatusCode (*DatabaseSetOption)(struct AdbcDatabase*, const char*, const char*,
+ struct AdbcError*);
+ AdbcStatusCode (*DatabaseRelease)(struct AdbcDatabase*, struct AdbcError*);
+
+ AdbcStatusCode (*ConnectionCommit)(struct AdbcConnection*, struct AdbcError*);
+ AdbcStatusCode (*ConnectionGetInfo)(struct AdbcConnection*, uint32_t*, size_t,
+ struct ArrowArrayStream*, struct AdbcError*);
+ AdbcStatusCode (*ConnectionGetObjects)(struct AdbcConnection*, int, const char*,
+ const char*, const char*, const char**,
+ const char*, struct ArrowArrayStream*,
+ struct AdbcError*);
+ AdbcStatusCode (*ConnectionGetTableSchema)(struct AdbcConnection*, const char*,
+ const char*, const char*,
+ struct ArrowSchema*, struct AdbcError*);
+ AdbcStatusCode (*ConnectionGetTableTypes)(struct AdbcConnection*,
+ struct ArrowArrayStream*, struct AdbcError*);
+ AdbcStatusCode (*ConnectionInit)(struct AdbcConnection*, struct AdbcDatabase*,
+ struct AdbcError*);
+ AdbcStatusCode (*ConnectionNew)(struct AdbcConnection*, struct AdbcError*);
+ AdbcStatusCode (*ConnectionSetOption)(struct AdbcConnection*, const char*, const char*,
+ struct AdbcError*);
+ AdbcStatusCode (*ConnectionReadPartition)(struct AdbcConnection*, const uint8_t*,
+ size_t, struct ArrowArrayStream*,
+ struct AdbcError*);
+ AdbcStatusCode (*ConnectionRelease)(struct AdbcConnection*, struct AdbcError*);
+ AdbcStatusCode (*ConnectionRollback)(struct AdbcConnection*, struct AdbcError*);
+
+ AdbcStatusCode (*StatementBind)(struct AdbcStatement*, struct ArrowArray*,
+ struct ArrowSchema*, struct AdbcError*);
+ AdbcStatusCode (*StatementBindStream)(struct AdbcStatement*, struct ArrowArrayStream*,
+ struct AdbcError*);
+ AdbcStatusCode (*StatementExecuteQuery)(struct AdbcStatement*, struct ArrowArrayStream*,
+ int64_t*, struct AdbcError*);
+ AdbcStatusCode (*StatementExecutePartitions)(struct AdbcStatement*, struct ArrowSchema*,
+ struct AdbcPartitions*, int64_t*,
+ struct AdbcError*);
+ AdbcStatusCode (*StatementGetParameterSchema)(struct AdbcStatement*,
+ struct ArrowSchema*, struct AdbcError*);
+ AdbcStatusCode (*StatementNew)(struct AdbcConnection*, struct AdbcStatement*,
+ struct AdbcError*);
+ AdbcStatusCode (*StatementPrepare)(struct AdbcStatement*, struct AdbcError*);
+ AdbcStatusCode (*StatementRelease)(struct AdbcStatement*, struct AdbcError*);
+ AdbcStatusCode (*StatementSetOption)(struct AdbcStatement*, const char*, const char*,
+ struct AdbcError*);
+ AdbcStatusCode (*StatementSetSqlQuery)(struct AdbcStatement*, const char*,
+ struct AdbcError*);
+ AdbcStatusCode (*StatementSetSubstraitPlan)(struct AdbcStatement*, const uint8_t*,
+ size_t, struct AdbcError*);
+};
+
+AdbcStatusCode Version100DriverInit(int version, void* driver, struct AdbcError* error);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/c/driver_manager/adbc_version_100_compatibility_test.cc b/c/driver_manager/adbc_version_100_compatibility_test.cc
new file mode 100644
index 00000000..634c126c
--- /dev/null
+++ b/c/driver_manager/adbc_version_100_compatibility_test.cc
@@ -0,0 +1,103 @@
+// 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.
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <memory>
+
+#include "adbc.h"
+#include "adbc_driver_manager.h"
+#include "adbc_version_100.h"
+#include "validation/adbc_validation_util.h"
+
+namespace adbc {
+
+using adbc_validation::IsOkStatus;
+using adbc_validation::IsStatus;
+
+class AdbcVersion : public ::testing::Test {
+ public:
+ void SetUp() override {
+ std::memset(&driver, 0, sizeof(driver));
+ std::memset(&error, 0, sizeof(error));
+ }
+
+ void TearDown() override {
+ if (error.release) {
+ error.release(&error);
+ }
+
+ if (driver.release) {
+ ASSERT_THAT(driver.release(&driver, &error), IsOkStatus(&error));
+ ASSERT_EQ(driver.private_data, nullptr);
+ ASSERT_EQ(driver.private_manager, nullptr);
+ }
+ }
+
+ protected:
+ struct AdbcDriver driver = {};
+ struct AdbcError error = {};
+};
+
+TEST_F(AdbcVersion, StructSize) {
+ ASSERT_EQ(sizeof(AdbcDriverVersion100), ADBC_DRIVER_1_0_0_SIZE);
+ ASSERT_EQ(sizeof(AdbcDriver), ADBC_DRIVER_1_1_0_SIZE);
+}
+
+// Initialize a version 1.0.0 driver with the version 1.1.0 driver struct.
+TEST_F(AdbcVersion, OldDriverNewLayout) {
+ ASSERT_THAT(Version100DriverInit(ADBC_VERSION_1_1_0, &driver, &error),
+ IsStatus(ADBC_STATUS_NOT_IMPLEMENTED, &error));
+
+ ASSERT_THAT(Version100DriverInit(ADBC_VERSION_1_0_0, &driver, &error),
+ IsOkStatus(&error));
+}
+
+// Initialize a version 1.0.0 driver with the new driver manager/new version.
+TEST_F(AdbcVersion, OldDriverNewManager) {
+ ASSERT_THAT(AdbcLoadDriverFromInitFunc(&Version100DriverInit, ADBC_VERSION_1_1_0,
+ &driver, &error),
+ IsOkStatus(&error));
+
+ ASSERT_NE(driver.DatabaseGetOption, nullptr);
+ ASSERT_NE(driver.DatabaseGetOptionInt, nullptr);
+ ASSERT_NE(driver.DatabaseGetOptionDouble, nullptr);
+ ASSERT_NE(driver.DatabaseSetOptionInt, nullptr);
+ ASSERT_NE(driver.DatabaseSetOptionDouble, nullptr);
+
+ ASSERT_NE(driver.ConnectionGetOption, nullptr);
+ ASSERT_NE(driver.ConnectionGetOptionInt, nullptr);
+ ASSERT_NE(driver.ConnectionGetOptionDouble, nullptr);
+ ASSERT_NE(driver.ConnectionSetOptionInt, nullptr);
+ ASSERT_NE(driver.ConnectionSetOptionDouble, nullptr);
+
+ ASSERT_NE(driver.StatementCancel, nullptr);
+ ASSERT_NE(driver.StatementExecuteSchema, nullptr);
+ ASSERT_NE(driver.StatementGetOption, nullptr);
+ ASSERT_NE(driver.StatementGetOptionInt, nullptr);
+ ASSERT_NE(driver.StatementGetOptionDouble, nullptr);
+ ASSERT_NE(driver.StatementSetOptionInt, nullptr);
+ ASSERT_NE(driver.StatementSetOptionDouble, nullptr);
+}
+
+// Initialize a version 1.1.0 driver with the version 1.0.0 driver struct.
+TEST_F(AdbcVersion, NewDriverOldLayout) {
+ // TODO: no new drivers yet.
+}
+
+} // namespace adbc
[arrow-adbc] 01/03: feat(format): introduce ADBC API revision 1.1.0 (#692)
Posted by li...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
lidavidm pushed a commit to branch spec-1.1.0
in repository https://gitbox.apache.org/repos/asf/arrow-adbc.git
commit e266f16810d0d01a8e6d0cf0255003620b59a403
Author: David Li <li...@gmail.com>
AuthorDate: Tue Jun 6 10:11:27 2023 -0400
feat(format): introduce ADBC API revision 1.1.0 (#692)
Fixes #317.
---------
Co-authored-by: Matt Topol <zo...@gmail.com>
Co-authored-by: Sutou Kouhei <ko...@cozmixng.org>
---
.pre-commit-config.yaml | 4 +-
adbc.h | 598 ++++++++++++++++++++-
c/driver/postgresql/postgresql.cc | 3 +-
c/driver/sqlite/sqlite.c | 2 +-
c/driver_manager/adbc_driver_manager.cc | 68 ++-
c/driver_manager/adbc_driver_manager_test.cc | 34 ++
go/adbc/adbc.go | 93 +++-
go/adbc/infocode_string.go | 7 +-
go/adbc/pkg/_tmpl/driver.go.tmpl | 2 +-
go/adbc/pkg/flightsql/driver.go | 2 +-
go/adbc/pkg/snowflake/driver.go | 2 +-
.../org/apache/arrow/adbc/core/AdbcConnection.java | 38 +-
.../org/apache/arrow/adbc/core/AdbcDatabase.java | 2 +-
.../org/apache/arrow/adbc/core/AdbcDriver.java | 35 +-
.../org/apache/arrow/adbc/core/AdbcInfoCode.java | 17 +-
.../org/apache/arrow/adbc/core/AdbcOptionKey.java | 69 +++
.../core/{AdbcDriver.java => AdbcOptions.java} | 32 +-
.../org/apache/arrow/adbc/core/AdbcStatement.java | 51 +-
.../org/apache/arrow/adbc/core/BulkIngestMode.java | 15 +-
19 files changed, 1026 insertions(+), 48 deletions(-)
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 82df862c..188b069b 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -43,12 +43,12 @@ repos:
- id: cmake-format
args: [--in-place]
- repo: https://github.com/cpplint/cpplint
- rev: 1.6.0
+ rev: 1.6.1
hooks:
- id: cpplint
args:
# From Arrow's config
- - "--filter=-whitespace/comments,-readability/casting,-readability/todo,-readability/alt_tokens,-build/header_guard,-build/c++11,-build/include_order,-build/include_subdir"
+ - "--filter=-whitespace/comments,-whitespace/indent,-readability/braces,-readability/casting,-readability/todo,-readability/alt_tokens,-build/header_guard,-build/c++11,-build/include_order,-build/include_subdir"
- "--linelength=90"
- "--verbose=2"
- repo: https://github.com/golangci/golangci-lint
diff --git a/adbc.h b/adbc.h
index 154e8812..756288da 100644
--- a/adbc.h
+++ b/adbc.h
@@ -279,6 +279,14 @@ struct ADBC_EXPORT AdbcError {
/// point to an AdbcDriver.
#define ADBC_VERSION_1_0_0 1000000
+/// \brief ADBC revision 1.1.0.
+///
+/// When passed to an AdbcDriverInitFunc(), the driver parameter must
+/// point to an AdbcDriver.
+///
+/// \addtogroup adbc-1.1.0
+#define ADBC_VERSION_1_1_0 1001000
+
/// \brief Canonical option value for enabling an option.
///
/// For use as the value in SetOption calls.
@@ -288,6 +296,37 @@ struct ADBC_EXPORT AdbcError {
/// For use as the value in SetOption calls.
#define ADBC_OPTION_VALUE_DISABLED "false"
+/// \brief Canonical option name for URIs.
+///
+/// Should be used as the expected option name to specify a URI for
+/// any ADBC driver.
+///
+/// The type is char*.
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+#define ADBC_OPTION_URI "uri"
+/// \brief Canonical option name for usernames.
+///
+/// Should be used as the expected option name to specify a username
+/// to a driver for authentication.
+///
+/// The type is char*.
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+#define ADBC_OPTION_USERNAME "username"
+/// \brief Canonical option name for passwords.
+///
+/// Should be used as the expected option name to specify a password
+/// for authentication to a driver.
+///
+/// The type is char*.
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+#define ADBC_OPTION_PASSWORD "password"
+
/// \brief The database vendor/product name (e.g. the server name).
/// (type: utf8).
///
@@ -315,6 +354,16 @@ struct ADBC_EXPORT AdbcError {
///
/// \see AdbcConnectionGetInfo
#define ADBC_INFO_DRIVER_ARROW_VERSION 102
+/// \brief The driver ADBC API version (type: int64).
+///
+/// The value should be one of the ADBC_VERSION constants.
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \see AdbcConnectionGetInfo
+/// \see ADBC_VERSION_1_0_0
+/// \see ADBC_VERSION_1_1_0
+#define ADBC_INFO_DRIVER_ADBC_VERSION 103
/// \brief Return metadata on catalogs, schemas, tables, and columns.
///
@@ -340,15 +389,68 @@ struct ADBC_EXPORT AdbcError {
/// \brief The name of the canonical option for whether autocommit is
/// enabled.
///
+/// The type is char*.
+///
/// \see AdbcConnectionSetOption
#define ADBC_CONNECTION_OPTION_AUTOCOMMIT "adbc.connection.autocommit"
/// \brief The name of the canonical option for whether the current
/// connection should be restricted to being read-only.
///
+/// The type is char*.
+///
/// \see AdbcConnectionSetOption
#define ADBC_CONNECTION_OPTION_READ_ONLY "adbc.connection.readonly"
+/// \brief The name of the canonical option for the current catalog.
+///
+/// The type is char*.
+///
+/// \see AdbcConnectionGetOption
+/// \see AdbcConnectionSetOption
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+#define ADBC_CONNECTION_OPTION_CURRENT_CATALOG "adbc.connection.catalog"
+
+/// \brief The name of the canonical option for the current schema.
+///
+/// The type is char*.
+///
+/// \see AdbcConnectionGetOption
+/// \see AdbcConnectionSetOption
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+#define ADBC_CONNECTION_OPTION_CURRENT_DB_SCHEMA "adbc.connection.db_schema"
+
+/// \brief The name of the canonical option for making query execution
+/// nonblocking.
+///
+/// When enabled, AdbcStatementExecutePartitions will return
+/// partitions as soon as they are available, instead of returning
+/// them all at the end. When there are no more to return, it will
+/// return an empty set of partitions. AdbcStatementExecuteQuery and
+/// AdbcStatementExecuteSchema are not affected.
+///
+/// The default is ADBC_OPTION_VALUE_DISABLED.
+///
+/// The type is char*.
+///
+/// \see AdbcStatementSetOption
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+#define ADBC_STATEMENT_OPTION_INCREMENTAL "adbc.statement.exec.incremental"
+
+/// \brief The name of the option for getting the progress of a query.
+///
+/// Progress is a value in [0.0, 1.0].
+///
+/// The type is double.
+///
+/// \see AdbcStatementGetOptionDouble
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+#define ADBC_STATEMENT_OPTION_PROGRESS "adbc.statement.exec.progress"
+
/// \brief The name of the canonical option for setting the isolation
/// level of a transaction.
///
@@ -357,6 +459,8 @@ struct ADBC_EXPORT AdbcError {
/// isolation level is not supported by a driver, it should return an
/// appropriate error.
///
+/// The type is char*.
+///
/// \see AdbcConnectionSetOption
#define ADBC_CONNECTION_OPTION_ISOLATION_LEVEL \
"adbc.connection.transaction.isolation_level"
@@ -449,8 +553,12 @@ struct ADBC_EXPORT AdbcError {
/// exist. If the table exists but has a different schema,
/// ADBC_STATUS_ALREADY_EXISTS should be raised. Else, data should be
/// appended to the target table.
+///
+/// The type is char*.
#define ADBC_INGEST_OPTION_TARGET_TABLE "adbc.ingest.target_table"
/// \brief Whether to create (the default) or append.
+///
+/// The type is char*.
#define ADBC_INGEST_OPTION_MODE "adbc.ingest.mode"
/// \brief Create the table and insert data; error if the table exists.
#define ADBC_INGEST_OPTION_MODE_CREATE "adbc.ingest.mode.create"
@@ -458,6 +566,17 @@ struct ADBC_EXPORT AdbcError {
/// table does not exist (ADBC_STATUS_NOT_FOUND) or does not match
/// the schema of the data to append (ADBC_STATUS_ALREADY_EXISTS).
#define ADBC_INGEST_OPTION_MODE_APPEND "adbc.ingest.mode.append"
+/// \brief Create the table and insert data; drop the original table
+/// if it already exists.
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+#define ADBC_INGEST_OPTION_MODE_REPLACE "adbc.ingest.mode.replace"
+/// \brief Insert data; create the table if it does not exist, or
+/// error if the table exists, but the schema does not match the
+/// schema of the data to append (ADBC_STATUS_ALREADY_EXISTS).
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+#define ADBC_INGEST_OPTION_MODE_CREATE_APPEND "adbc.ingest.mode.create_append"
/// @}
@@ -667,8 +786,89 @@ struct ADBC_EXPORT AdbcDriver {
struct AdbcError*);
AdbcStatusCode (*StatementSetSubstraitPlan)(struct AdbcStatement*, const uint8_t*,
size_t, struct AdbcError*);
+
+ /// \defgroup adbc-1.1.0 ADBC API Revision 1.1.0
+ ///
+ /// Functions added in ADBC 1.1.0. For backwards compatibility,
+ /// these members must not be accessed unless the version passed to
+ /// the AdbcDriverInitFunc is greater than or equal to
+ /// ADBC_VERSION_1_1_0.
+ ///
+ /// For a 1.0.0 driver being loaded by a 1.1.0 driver manager: the
+ /// 1.1.0 manager will allocate the new, expanded AdbcDriver struct
+ /// and attempt to have the driver initialize it with
+ /// ADBC_VERSION_1_1_0. This must return an error, after which the
+ /// driver will try again with ADBC_VERSION_1_0_0. The driver must
+ /// not access the new fields.
+ ///
+ /// For a 1.1.0 driver being loaded by a 1.0.0 driver manager: the
+ /// 1.0.0 manager will allocate the old AdbcDriver struct and
+ /// attempt to have the driver initialize it with
+ /// ADBC_VERSION_1_0_0. The driver must not access the new fields,
+ /// and should initialize the old fields.
+ ///
+ /// @{
+
+ AdbcStatusCode (*DatabaseGetOption)(struct AdbcDatabase*, const char*, const char**,
+ struct AdbcError*);
+ AdbcStatusCode (*DatabaseGetOptionInt)(struct AdbcDatabase*, const char*, int64_t*,
+ struct AdbcError*);
+ AdbcStatusCode (*DatabaseGetOptionDouble)(struct AdbcDatabase*, const char*, double*,
+ struct AdbcError*);
+ AdbcStatusCode (*DatabaseSetOptionInt)(struct AdbcDatabase*, const char*, int64_t,
+ struct AdbcError*);
+ AdbcStatusCode (*DatabaseSetOptionDouble)(struct AdbcDatabase*, const char*, double,
+ struct AdbcError*);
+
+ AdbcStatusCode (*ConnectionGetOption)(struct AdbcConnection*, const char*, const char**,
+ struct AdbcError*);
+ AdbcStatusCode (*ConnectionGetOptionInt)(struct AdbcConnection*, const char*, int64_t*,
+ struct AdbcError*);
+ AdbcStatusCode (*ConnectionGetOptionDouble)(struct AdbcConnection*, const char*,
+ double*, struct AdbcError*);
+ AdbcStatusCode (*ConnectionSetOptionInt)(struct AdbcConnection*, const char*, int64_t,
+ struct AdbcError*);
+ AdbcStatusCode (*ConnectionSetOptionDouble)(struct AdbcConnection*, const char*, double,
+ struct AdbcError*);
+
+ AdbcStatusCode (*StatementCancel)(struct AdbcStatement*, struct AdbcError*);
+ AdbcStatusCode (*StatementExecuteSchema)(struct AdbcStatement*, struct ArrowSchema*,
+ struct AdbcError*);
+ AdbcStatusCode (*StatementGetOption)(struct AdbcStatement*, const char*, const char**,
+ struct AdbcError*);
+ AdbcStatusCode (*StatementGetOptionInt)(struct AdbcStatement*, const char*, int64_t*,
+ struct AdbcError*);
+ AdbcStatusCode (*StatementGetOptionDouble)(struct AdbcStatement*, const char*, double*,
+ struct AdbcError*);
+ AdbcStatusCode (*StatementSetOptionInt)(struct AdbcStatement*, const char*, int64_t,
+ struct AdbcError*);
+ AdbcStatusCode (*StatementSetOptionDouble)(struct AdbcStatement*, const char*, double,
+ struct AdbcError*);
+
+ /// Pad the struct to have 96 pointers. Space reserved for future growth.
+ void* reserved[50];
+
+ /// @}
};
+/// \brief The size of the AdbcDriver structure in ADBC 1.0.0.
+/// Drivers written for ADBC 1.1.0 and later should never touch more
+/// than this portion of an AdbcDriver struct when given
+/// ADBC_VERSION_1_0_0.
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+#define ADBC_DRIVER_1_0_0_SIZE (offsetof(struct AdbcDriver, DatabaseGetOption))
+
+/// \brief The size of the AdbcDriver structure in ADBC 1.1.0.
+/// Drivers written for ADBC 1.1.0 and later should never touch more
+/// than this portion of an AdbcDriver struct when given
+/// ADBC_VERSION_1_1_0.
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+#define ADBC_DRIVER_1_1_0_SIZE (sizeof(struct AdbcDriver))
+
/// @}
/// \addtogroup adbc-database
@@ -684,16 +884,121 @@ struct ADBC_EXPORT AdbcDriver {
ADBC_EXPORT
AdbcStatusCode AdbcDatabaseNew(struct AdbcDatabase* database, struct AdbcError* error);
+/// \brief Get a string option of the database.
+///
+/// This must always be thread-safe (other operations are not).
+///
+/// The returned option value is only valid until the next call to
+/// GetOption or Release.
+///
+/// For standard options, drivers must always support getting the
+/// option value (if they support getting option values at all) via
+/// the type specified in the option. (For example, an option set via
+/// SetOptionDouble must be retrievable via GetOptionDouble.) Drivers
+/// may also support getting a converted option value via other
+/// getters if needed. (For example, getting the string
+/// representation of a double option.)
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] database The database.
+/// \param[in] key The option to get.
+/// \param[out] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
+AdbcStatusCode AdbcDatabaseGetOption(struct AdbcDatabase* database, const char* key,
+ const char** value, struct AdbcError* error);
+
+/// \brief Get an integer option of the database.
+///
+/// This must always be thread-safe (other operations are not).
+///
+/// For standard options, drivers must always support getting the
+/// option value (if they support getting option values at all) via
+/// the type specified in the option. (For example, an option set via
+/// SetOptionDouble must be retrievable via GetOptionDouble.) Drivers
+/// may also support getting a converted option value via other
+/// getters if needed. (For example, getting the integer
+/// representation of a double option.)
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] database The database.
+/// \param[in] key The option to get.
+/// \param[out] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
+AdbcStatusCode AdbcDatabaseGetOptionInt(struct AdbcDatabase* database, const char* key,
+ int64_t* value, struct AdbcError* error);
+
+/// \brief Get a double option of the database.
+///
+/// This must always be thread-safe (other operations are not).
+///
+/// For standard options, drivers must always support getting the
+/// option value (if they support getting option values at all) via
+/// the type specified in the option. (For example, an option set via
+/// SetOptionDouble must be retrievable via GetOptionDouble.) Drivers
+/// may also support getting a converted option value via other
+/// getters if needed. (For example, getting the double
+/// representation of an integer option.)
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] database The database.
+/// \param[in] key The option to get.
+/// \param[out] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
+AdbcStatusCode AdbcDatabaseGetOptionDouble(struct AdbcDatabase* database, const char* key,
+ double* value, struct AdbcError* error);
+
/// \brief Set a char* option.
///
/// Options may be set before AdbcDatabaseInit. Some drivers may
/// support setting options after initialization as well.
///
+/// \param[in] database The database.
+/// \param[in] key The option to set.
+/// \param[in] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
ADBC_EXPORT
AdbcStatusCode AdbcDatabaseSetOption(struct AdbcDatabase* database, const char* key,
const char* value, struct AdbcError* error);
+/// \brief Set an integer option on a database.
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] database The database.
+/// \param[in] key The option to set.
+/// \param[in] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
+ADBC_EXPORT
+AdbcStatusCode AdbcDatabaseSetOptionInt(struct AdbcDatabase* database, const char* key,
+ int64_t value, struct AdbcError* error);
+
+/// \brief Set a double option on a database.
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] database The database.
+/// \param[in] key The option to set.
+/// \param[in] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
+ADBC_EXPORT
+AdbcStatusCode AdbcDatabaseSetOptionDouble(struct AdbcDatabase* database, const char* key,
+ double value, struct AdbcError* error);
+
/// \brief Finish setting options and initialize the database.
///
/// Some drivers may support setting options after initialization
@@ -730,11 +1035,52 @@ AdbcStatusCode AdbcConnectionNew(struct AdbcConnection* connection,
/// Options may be set before AdbcConnectionInit. Some drivers may
/// support setting options after initialization as well.
///
+/// \param[in] connection The database connection.
+/// \param[in] key The option to set.
+/// \param[in] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
ADBC_EXPORT
AdbcStatusCode AdbcConnectionSetOption(struct AdbcConnection* connection, const char* key,
const char* value, struct AdbcError* error);
+/// \brief Set an integer option.
+///
+/// Options may be set before AdbcConnectionInit. Some drivers may
+/// support setting options after initialization as well.
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] connection The database connection.
+/// \param[in] key The option to set.
+/// \param[in] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
+ADBC_EXPORT
+AdbcStatusCode AdbcConnectionSetOptionInt(struct AdbcConnection* connection,
+ const char* key, int64_t value,
+ struct AdbcError* error);
+
+/// \brief Set a double option.
+///
+/// Options may be set before AdbcConnectionInit. Some drivers may
+/// support setting options after initialization as well.
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] connection The database connection.
+/// \param[in] key The option to set.
+/// \param[in] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
+ADBC_EXPORT
+AdbcStatusCode AdbcConnectionSetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double value,
+ struct AdbcError* error);
+
/// \brief Finish setting options and initialize the connection.
///
/// Some drivers may support setting options after initialization
@@ -765,6 +1111,8 @@ AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection* connection,
/// concurrent active statements and it must execute a SQL query
/// internally in order to implement the metadata function).
///
+/// This AdbcConnection must outlive the returned ArrowArrayStream.
+///
/// Some functions accept "search pattern" arguments, which are
/// strings that can contain the special character "%" to match zero
/// or more characters, or "_" to match exactly one character. (See
@@ -799,6 +1147,10 @@ AdbcStatusCode AdbcConnectionRelease(struct AdbcConnection* connection,
/// for ADBC usage. Drivers/vendors will ignore requests for
/// unrecognized codes (the row will be omitted from the result).
///
+/// Since ADBC 1.1.0: the range [500, 1_000) is reserved for "XDBC"
+/// information, which is the same metadata provided by the same info
+/// code range in the Arrow Flight SQL GetSqlInfo RPC.
+///
/// \param[in] connection The connection to query.
/// \param[in] info_codes A list of metadata codes to fetch, or NULL
/// to fetch all.
@@ -891,6 +1243,8 @@ AdbcStatusCode AdbcConnectionGetInfo(struct AdbcConnection* connection,
/// | fk_table | utf8 not null |
/// | fk_column_name | utf8 not null |
///
+/// This AdbcConnection must outlive the returned ArrowArrayStream.
+///
/// \param[in] connection The database connection.
/// \param[in] depth The level of nesting to display. If 0, display
/// all levels. If 1, display only catalogs (i.e. catalog_schemas
@@ -922,6 +1276,80 @@ AdbcStatusCode AdbcConnectionGetObjects(struct AdbcConnection* connection, int d
struct ArrowArrayStream* out,
struct AdbcError* error);
+/// \brief Get a string option of the connection.
+///
+/// This must always be thread-safe (other operations are not).
+///
+/// The returned option value is only valid until the next call to
+/// GetOption or Release.
+///
+/// For standard options, drivers must always support getting the
+/// option value (if they support getting option values at all) via
+/// the type specified in the option. (For example, an option set via
+/// SetOptionDouble must be retrievable via GetOptionDouble.) Drivers
+/// may also support getting a converted option value via other
+/// getters if needed. (For example, getting the string
+/// representation of a double option.)
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] connection The database connection.
+/// \param[in] key The option to get.
+/// \param[out] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
+AdbcStatusCode AdbcConnectionGetOption(struct AdbcConnection* connection, const char* key,
+ const char** value, struct AdbcError* error);
+
+/// \brief Get an integer option of the connection.
+///
+/// This must always be thread-safe (other operations are not).
+///
+/// For standard options, drivers must always support getting the
+/// option value (if they support getting option values at all) via
+/// the type specified in the option. (For example, an option set via
+/// SetOptionDouble must be retrievable via GetOptionDouble.) Drivers
+/// may also support getting a converted option value via other
+/// getters if needed. (For example, getting the string
+/// representation of a double option.)
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] connection The database connection.
+/// \param[in] key The option to get.
+/// \param[out] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
+AdbcStatusCode AdbcConnectionGetOptionInt(struct AdbcConnection* connection,
+ const char* key, int64_t* value,
+ struct AdbcError* error);
+
+/// \brief Get a double option of the connection.
+///
+/// This must always be thread-safe (other operations are not).
+///
+/// For standard options, drivers must always support getting the
+/// option value (if they support getting option values at all) via
+/// the type specified in the option. (For example, an option set via
+/// SetOptionDouble must be retrievable via GetOptionDouble.) Drivers
+/// may also support getting a converted option value via other
+/// getters if needed. (For example, getting the string
+/// representation of a double option.)
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] connection The database connection.
+/// \param[in] key The option to get.
+/// \param[out] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
+AdbcStatusCode AdbcConnectionGetOptionDouble(struct AdbcConnection* connection,
+ const char* key, double* value,
+ struct AdbcError* error);
+
/// \brief Get the Arrow schema of a table.
///
/// \param[in] connection The database connection.
@@ -945,6 +1373,8 @@ AdbcStatusCode AdbcConnectionGetTableSchema(struct AdbcConnection* connection,
/// ---------------|--------------
/// table_type | utf8 not null
///
+/// This AdbcConnection must outlive the returned ArrowArrayStream.
+///
/// \param[in] connection The database connection.
/// \param[out] out The result set.
/// \param[out] error Error details, if an error occurs.
@@ -973,6 +1403,8 @@ AdbcStatusCode AdbcConnectionGetTableTypes(struct AdbcConnection* connection,
///
/// A partition can be retrieved from AdbcPartitions.
///
+/// This AdbcConnection must outlive the returned ArrowArrayStream.
+///
/// \param[in] connection The connection to use. This does not have
/// to be the same connection that the partition was created on.
/// \param[in] serialized_partition The partition descriptor.
@@ -1042,7 +1474,11 @@ AdbcStatusCode AdbcStatementRelease(struct AdbcStatement* statement,
/// \brief Execute a statement and get the results.
///
-/// This invalidates any prior result sets.
+/// This invalidates any prior result sets. This AdbcStatement must
+/// outlive the returned ArrowArrayStream.
+///
+/// Since ADBC 1.1.0: releasing the returned ArrowArrayStream without
+/// consuming it fully is equivalent to calling AdbcStatementCancel.
///
/// \param[in] statement The statement to execute.
/// \param[out] out The results. Pass NULL if the client does not
@@ -1056,6 +1492,25 @@ AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement* statement,
struct ArrowArrayStream* out,
int64_t* rows_affected, struct AdbcError* error);
+/// \brief Get the schema of the result set of a query without
+/// executing it.
+///
+/// This invalidates any prior result sets.
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+///
+/// \param[in] statement The statement to execute.
+/// \param[out] out The result schema.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+///
+/// \return ADBC_STATUS_NOT_IMPLEMENTED if the driver does not support this.
+ADBC_EXPORT
+AdbcStatusCode AdbcStatementExecuteSchema(struct AdbcStatement* statement,
+ struct ArrowSchema* schema,
+ struct AdbcError* error);
+
/// \brief Turn this statement into a prepared statement to be
/// executed multiple times.
///
@@ -1138,6 +1593,102 @@ AdbcStatusCode AdbcStatementBindStream(struct AdbcStatement* statement,
struct ArrowArrayStream* stream,
struct AdbcError* error);
+/// \brief Cancel execution of an in-progress query.
+///
+/// This can be called during AdbcStatementExecuteQuery (or similar),
+/// or while consuming an ArrowArrayStream returned from such.
+/// Calling this function should make the other functions return
+/// ADBC_STATUS_CANCELLED (from ADBC functions) or ECANCELED (from
+/// methods of ArrowArrayStream).
+///
+/// This must always be thread-safe (other operations are not).
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+///
+/// \param[in] statement The statement to cancel.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+///
+/// \return ADBC_STATUS_INVALID_STATE if there is no query to cancel.
+/// \return ADBC_STATUS_UNKNOWN if the query could not be cancelled.
+ADBC_EXPORT
+AdbcStatusCode AdbcStatementCancel(struct AdbcStatement* statement,
+ struct AdbcError* error);
+
+/// \brief Get a string option of the statement.
+///
+/// This must always be thread-safe (other operations are not).
+///
+/// The returned option value is only valid until the next call to
+/// GetOption or Release.
+///
+/// For standard options, drivers must always support getting the
+/// option value (if they support getting option values at all) via
+/// the type specified in the option. (For example, an option set via
+/// SetOptionDouble must be retrievable via GetOptionDouble.) Drivers
+/// may also support getting a converted option value via other
+/// getters if needed. (For example, getting the string
+/// representation of a double option.)
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] statement The statement.
+/// \param[in] key The option to get.
+/// \param[out] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
+AdbcStatusCode AdbcStatementGetOption(struct AdbcStatement* statement, const char* key,
+ const char** value, struct AdbcError* error);
+
+/// \brief Get an integer option of the statement.
+///
+/// This must always be thread-safe (other operations are not).
+///
+/// For standard options, drivers must always support getting the
+/// option value (if they support getting option values at all) via
+/// the type specified in the option. (For example, an option set via
+/// SetOptionDouble must be retrievable via GetOptionDouble.) Drivers
+/// may also support getting a converted option value via other
+/// getters if needed. (For example, getting the string
+/// representation of a double option.)
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] statement The statement.
+/// \param[in] key The option to get.
+/// \param[out] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
+AdbcStatusCode AdbcStatementGetOptionInt(struct AdbcStatement* statement, const char* key,
+ int64_t* value, struct AdbcError* error);
+
+/// \brief Get a double option of the statement.
+///
+/// This must always be thread-safe (other operations are not).
+///
+/// For standard options, drivers must always support getting the
+/// option value (if they support getting option values at all) via
+/// the type specified in the option. (For example, an option set via
+/// SetOptionDouble must be retrievable via GetOptionDouble.) Drivers
+/// may also support getting a converted option value via other
+/// getters if needed. (For example, getting the string
+/// representation of a double option.)
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] statement The statement.
+/// \param[in] key The option to get.
+/// \param[out] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_FOUND if the option is not recognized.
+AdbcStatusCode AdbcStatementGetOptionDouble(struct AdbcStatement* statement,
+ const char* key, double* value,
+ struct AdbcError* error);
+
/// \brief Get the schema for bound parameters.
///
/// This retrieves an Arrow schema describing the number, names, and
@@ -1159,10 +1710,45 @@ AdbcStatusCode AdbcStatementGetParameterSchema(struct AdbcStatement* statement,
struct AdbcError* error);
/// \brief Set a string option on a statement.
+/// \param[in] statement The statement.
+/// \param[in] key The option to set.
+/// \param[in] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized.
ADBC_EXPORT
AdbcStatusCode AdbcStatementSetOption(struct AdbcStatement* statement, const char* key,
const char* value, struct AdbcError* error);
+/// \brief Set an integer option on a statement.
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] statement The statement.
+/// \param[in] key The option to set.
+/// \param[in] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
+ADBC_EXPORT
+AdbcStatusCode AdbcStatementSetOptionInt(struct AdbcStatement* statement, const char* key,
+ int64_t value, struct AdbcError* error);
+
+/// \brief Set a double option on a statement.
+///
+/// \since ADBC API revision 1.1.0
+/// \addtogroup adbc-1.1.0
+/// \param[in] statement The statement.
+/// \param[in] key The option to set.
+/// \param[in] value The option value.
+/// \param[out] error An optional location to return an error
+/// message if necessary.
+/// \return ADBC_STATUS_NOT_IMPLEMENTED if the option is not recognized
+ADBC_EXPORT
+AdbcStatusCode AdbcStatementSetOptionDouble(struct AdbcStatement* statement,
+ const char* key, double value,
+ struct AdbcError* error);
+
/// \addtogroup adbc-statement-partition
/// @{
@@ -1198,7 +1784,15 @@ AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement* statement,
/// driver.
///
/// Although drivers may choose any name for this function, the
-/// recommended name is "AdbcDriverInit".
+/// recommended name is "AdbcDriverInit", or a name derived from the
+/// name of the driver's shared library as follows: remove the 'lib'
+/// prefix (on Unix systems) and all file extensions, then PascalCase
+/// the driver name, append Init, and prepend Adbc (if not already
+/// there). For example:
+///
+/// - libadbc_driver_sqlite.so.2.0.0 -> AdbcDriverSqliteInit
+/// - adbc_driver_sqlite.dll -> AdbcDriverSqliteInit
+/// - proprietary_driver.dll -> AdbcProprietaryDriverInit
///
/// \param[in] version The ADBC revision to attempt to initialize (see
/// ADBC_VERSION_1_0_0).
diff --git a/c/driver/postgresql/postgresql.cc b/c/driver/postgresql/postgresql.cc
index 29fd04cd..95e6c8b8 100644
--- a/c/driver/postgresql/postgresql.cc
+++ b/c/driver/postgresql/postgresql.cc
@@ -471,9 +471,10 @@ extern "C" {
ADBC_EXPORT
AdbcStatusCode AdbcDriverInit(int version, void* raw_driver, struct AdbcError* error) {
if (version != ADBC_VERSION_1_0_0) return ADBC_STATUS_NOT_IMPLEMENTED;
+ if (!raw_driver) return ADBC_STATUS_INVALID_ARGUMENT;
auto* driver = reinterpret_cast<struct AdbcDriver*>(raw_driver);
- std::memset(driver, 0, sizeof(*driver));
+ std::memset(driver, 0, ADBC_DRIVER_1_0_0_SIZE);
driver->DatabaseInit = PostgresDatabaseInit;
driver->DatabaseNew = PostgresDatabaseNew;
driver->DatabaseRelease = PostgresDatabaseRelease;
diff --git a/c/driver/sqlite/sqlite.c b/c/driver/sqlite/sqlite.c
index 4124098f..359c594d 100644
--- a/c/driver/sqlite/sqlite.c
+++ b/c/driver/sqlite/sqlite.c
@@ -1340,7 +1340,7 @@ AdbcStatusCode SqliteDriverInit(int version, void* raw_driver, struct AdbcError*
}
struct AdbcDriver* driver = (struct AdbcDriver*)raw_driver;
- memset(driver, 0, sizeof(*driver));
+ memset(driver, 0, ADBC_DRIVER_1_0_0_SIZE);
driver->DatabaseInit = SqliteDatabaseInit;
driver->DatabaseNew = SqliteDatabaseNew;
driver->DatabaseRelease = SqliteDatabaseRelease;
diff --git a/c/driver_manager/adbc_driver_manager.cc b/c/driver_manager/adbc_driver_manager.cc
index c63560a4..888c48a6 100644
--- a/c/driver_manager/adbc_driver_manager.cc
+++ b/c/driver_manager/adbc_driver_manager.cc
@@ -19,6 +19,7 @@
#include <adbc.h>
#include <algorithm>
+#include <array>
#include <cstring>
#include <string>
#include <unordered_map>
@@ -191,6 +192,12 @@ AdbcStatusCode StatementExecutePartitions(struct AdbcStatement* statement,
return ADBC_STATUS_NOT_IMPLEMENTED;
}
+AdbcStatusCode StatementExecuteSchema(struct AdbcStatement* statement,
+ struct ArrowSchema* schema,
+ struct AdbcError* error) {
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+}
+
AdbcStatusCode StatementGetParameterSchema(struct AdbcStatement* statement,
struct ArrowSchema* schema,
struct AdbcError* error) {
@@ -540,6 +547,15 @@ AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement* statement,
error);
}
+AdbcStatusCode AdbcStatementExecuteSchema(struct AdbcStatement* statement,
+ struct ArrowSchema* schema,
+ struct AdbcError* error) {
+ if (!statement->private_driver) {
+ return ADBC_STATUS_INVALID_STATE;
+ }
+ return statement->private_driver->StatementExecuteSchema(statement, schema, error);
+}
+
AdbcStatusCode AdbcStatementGetParameterSchema(struct AdbcStatement* statement,
struct ArrowSchema* schema,
struct AdbcError* error) {
@@ -640,11 +656,19 @@ AdbcStatusCode AdbcLoadDriver(const char* driver_name, const char* entrypoint,
AdbcDriverInitFunc init_func;
std::string error_message;
- if (version != ADBC_VERSION_1_0_0) {
- SetError(error, "Only ADBC 1.0.0 is supported");
- return ADBC_STATUS_NOT_IMPLEMENTED;
+ switch (version) {
+ case ADBC_VERSION_1_0_0:
+ case ADBC_VERSION_1_1_0:
+ break;
+ default:
+ SetError(error, "Only ADBC 1.0.0 and 1.1.0 are supported");
+ return ADBC_STATUS_NOT_IMPLEMENTED;
}
+ if (!raw_driver) {
+ SetError(error, "Must provide non-NULL raw_driver");
+ return ADBC_STATUS_INVALID_ARGUMENT;
+ }
auto* driver = reinterpret_cast<struct AdbcDriver*>(raw_driver);
if (!entrypoint) {
@@ -771,6 +795,25 @@ AdbcStatusCode AdbcLoadDriver(const char* driver_name, const char* entrypoint,
AdbcStatusCode AdbcLoadDriverFromInitFunc(AdbcDriverInitFunc init_func, int version,
void* raw_driver, struct AdbcError* error) {
+ constexpr std::array<int, 2> kSupportedVersions = {
+ ADBC_VERSION_1_1_0,
+ ADBC_VERSION_1_0_0,
+ };
+
+ if (!raw_driver) {
+ SetError(error, "Must provide non-NULL raw_driver");
+ return ADBC_STATUS_INVALID_ARGUMENT;
+ }
+
+ switch (version) {
+ case ADBC_VERSION_1_0_0:
+ case ADBC_VERSION_1_1_0:
+ break;
+ default:
+ SetError(error, "Only ADBC 1.0.0 and 1.1.0 are supported");
+ return ADBC_STATUS_NOT_IMPLEMENTED;
+ }
+
#define FILL_DEFAULT(DRIVER, STUB) \
if (!DRIVER->STUB) { \
DRIVER->STUB = &STUB; \
@@ -781,12 +824,20 @@ AdbcStatusCode AdbcLoadDriverFromInitFunc(AdbcDriverInitFunc init_func, int vers
return ADBC_STATUS_INTERNAL; \
}
- auto result = init_func(version, raw_driver, error);
+ // Starting from the passed version, try each (older) version in
+ // succession with the underlying driver until we find one that's
+ // accepted.
+ AdbcStatusCode result = ADBC_STATUS_NOT_IMPLEMENTED;
+ for (const int try_version : kSupportedVersions) {
+ if (try_version > version) continue;
+ result = init_func(try_version, raw_driver, error);
+ if (result != ADBC_STATUS_NOT_IMPLEMENTED) break;
+ }
if (result != ADBC_STATUS_OK) {
return result;
}
- if (version == ADBC_VERSION_1_0_0) {
+ if (version >= ADBC_VERSION_1_0_0) {
auto* driver = reinterpret_cast<struct AdbcDriver*>(raw_driver);
CHECK_REQUIRED(driver, DatabaseNew);
CHECK_REQUIRED(driver, DatabaseInit);
@@ -816,6 +867,13 @@ AdbcStatusCode AdbcLoadDriverFromInitFunc(AdbcDriverInitFunc init_func, int vers
FILL_DEFAULT(driver, StatementSetSqlQuery);
FILL_DEFAULT(driver, StatementSetSubstraitPlan);
}
+ if (version >= ADBC_VERSION_1_1_0) {
+ auto* driver = reinterpret_cast<struct AdbcDriver*>(raw_driver);
+ FILL_DEFAULT(driver, StatementExecuteSchema);
+
+ // Zero out the padding
+ std::memset(driver->reserved, 0, sizeof(driver->reserved));
+ }
return ADBC_STATUS_OK;
diff --git a/c/driver_manager/adbc_driver_manager_test.cc b/c/driver_manager/adbc_driver_manager_test.cc
index 99fa477b..26c8dc61 100644
--- a/c/driver_manager/adbc_driver_manager_test.cc
+++ b/c/driver_manager/adbc_driver_manager_test.cc
@@ -34,6 +34,8 @@ namespace adbc {
using adbc_validation::IsOkStatus;
using adbc_validation::IsStatus;
+TEST(Adbc, AdbcDriverSize) { ASSERT_EQ(sizeof(AdbcDriver), 96 * sizeof(void*)); }
+
class DriverManager : public ::testing::Test {
public:
void SetUp() override {
@@ -157,6 +159,38 @@ TEST_F(DriverManager, MultiDriverTest) {
error->release(&error.value);
}
+class AdbcVersion : public ::testing::Test {
+ public:
+ void SetUp() override {
+ std::memset(&driver, 0, sizeof(driver));
+ std::memset(&error, 0, sizeof(error));
+ }
+
+ void TearDown() override {
+ if (error.release) {
+ error.release(&error);
+ }
+
+ if (driver.release) {
+ ASSERT_THAT(driver.release(&driver, &error), IsOkStatus(&error));
+ ASSERT_EQ(driver.private_data, nullptr);
+ ASSERT_EQ(driver.private_manager, nullptr);
+ }
+ }
+
+ protected:
+ struct AdbcDriver driver = {};
+ struct AdbcError error = {};
+};
+
+// TODO: set up a dummy driver to test behavior more deterministically
+
+TEST_F(AdbcVersion, ForwardsCompatible) {
+ ASSERT_THAT(
+ AdbcLoadDriver("adbc_driver_sqlite", nullptr, ADBC_VERSION_1_1_0, &driver, &error),
+ IsOkStatus(&error));
+}
+
class SqliteQuirks : public adbc_validation::DriverQuirks {
public:
AdbcStatusCode SetupDatabase(struct AdbcDatabase* database,
diff --git a/go/adbc/adbc.go b/go/adbc/adbc.go
index 92df909b..bc03d428 100644
--- a/go/adbc/adbc.go
+++ b/go/adbc/adbc.go
@@ -142,20 +142,35 @@ const (
StatusUnauthorized // Unauthorized
)
+const (
+ AdbcVersion1_0_0 int64 = 1_000_000
+ AdbcVersion1_1_0 int64 = 1_001_000
+)
+
// Canonical option values
const (
- OptionValueEnabled = "true"
- OptionValueDisabled = "false"
- OptionKeyAutoCommit = "adbc.connection.autocommit"
- OptionKeyIngestTargetTable = "adbc.ingest.target_table"
- OptionKeyIngestMode = "adbc.ingest.mode"
- OptionKeyIsolationLevel = "adbc.connection.transaction.isolation_level"
- OptionKeyReadOnly = "adbc.connection.readonly"
- OptionValueIngestModeCreate = "adbc.ingest.mode.create"
- OptionValueIngestModeAppend = "adbc.ingest.mode.append"
- OptionKeyURI = "uri"
- OptionKeyUsername = "username"
- OptionKeyPassword = "password"
+ OptionValueEnabled = "true"
+ OptionValueDisabled = "false"
+ OptionKeyAutoCommit = "adbc.connection.autocommit"
+ // The current catalog.
+ OptionKeyCurrentCatalog = "adbc.connection.catalog"
+ // The current schema.
+ OptionKeyCurrentDbSchema = "adbc.connection.db_schema"
+ // Make ExecutePartitions nonblocking.
+ OptionKeyIncremental = "adbc.statement.exec.incremental"
+ // Get the progress
+ OptionKeyProgress = "adbc.statement.exec.progress"
+ OptionKeyIngestTargetTable = "adbc.ingest.target_table"
+ OptionKeyIngestMode = "adbc.ingest.mode"
+ OptionKeyIsolationLevel = "adbc.connection.transaction.isolation_level"
+ OptionKeyReadOnly = "adbc.connection.readonly"
+ OptionValueIngestModeCreate = "adbc.ingest.mode.create"
+ OptionValueIngestModeAppend = "adbc.ingest.mode.append"
+ OptionValueIngestModeReplace = "adbc.ingest.mode.replace"
+ OptionValueIngestModeCreateAppend = "adbc.ingest.mode.create_append"
+ OptionKeyURI = "uri"
+ OptionKeyUsername = "username"
+ OptionKeyPassword = "password"
)
type OptionIsolationLevel string
@@ -170,6 +185,11 @@ const (
LevelLinearizable OptionIsolationLevel = "adbc.connection.transaction.isolation.linearizable"
)
+// Canonical property values
+const (
+ PropertyProgress = "adbc.statement.exec.progress"
+)
+
// Driver is the entry point for the interface. It is similar to
// database/sql.Driver taking a map of keys and values as options
// to initialize a Connection to the database. Any common connection
@@ -212,6 +232,8 @@ const (
InfoDriverVersion InfoCode = 101 // DriverVersion
// The driver Arrow library version (type: utf8)
InfoDriverArrowVersion InfoCode = 102 // DriverArrowVersion
+ // The driver ADBC API version (type: int64)
+ InfoDriverADBCVersion InfoCode = 103 // DriverADBCVersion
)
type ObjectDepth int
@@ -275,6 +297,10 @@ type Connection interface {
// codes are defined as constants. Codes [0, 10_000) are reserved
// for ADBC usage. Drivers/vendors will ignore requests for unrecognized
// codes (the row will be omitted from the result).
+ //
+ // Since ADBC 1.1.0: the range [500, 1_000) is reserved for "XDBC"
+ // information, which is the same metadata provided by the same info
+ // code range in the Arrow Flight SQL GetSqlInfo RPC.
GetInfo(ctx context.Context, infoCodes []InfoCode) (array.RecordReader, error)
// GetObjects gets a hierarchical view of all catalogs, database schemas,
@@ -470,6 +496,9 @@ type Statement interface {
// of rows affected if known, otherwise it will be -1.
//
// This invalidates any prior result sets on this statement.
+ //
+ // Since ADBC 1.1.0: releasing the returned RecordReader without
+ // consuming it fully is equivalent to calling AdbcStatementCancel.
ExecuteQuery(context.Context) (array.RecordReader, int64, error)
// ExecuteUpdate executes a statement that does not generate a result
@@ -534,5 +563,45 @@ type Statement interface {
//
// If the driver does not support partitioned results, this will return
// an error with a StatusNotImplemented code.
+ //
+ // When OptionKeyIncremental is set, this should be called
+ // repeatedly until receiving an empty Partitions.
ExecutePartitions(context.Context) (*arrow.Schema, Partitions, int64, error)
}
+
+// StatementCancel is a Statement that also supports Cancel.
+//
+// Since ADBC API revision 1.1.0.
+type StatementCancel interface {
+ // Cancel stops execution of an in-progress query.
+ //
+ // This can be called during ExecuteQuery (or similar), or while
+ // consuming a RecordReader returned from such. Calling this
+ // function should make the other functions return an error with a
+ // StatusCancelled code.
+ //
+ // This must always be thread-safe (other operations are not
+ // necessarily thread-safe).
+ Cancel() error
+}
+
+// StatementExecuteSchema is a Statement that also supports ExecuteSchema.
+//
+// Since ADBC API revision 1.1.0.
+type StatementExecuteSchema interface {
+ // ExecuteSchema gets the schema of the result set of a query without executing it.
+ ExecuteSchema(context.Context) (*arrow.Schema, error)
+}
+
+// GetSetOptions is a PostInitOptions that also supports getting and setting property values of different types.
+//
+// Since ADBC API revision 1.1.0.
+type GetSetOptions interface {
+ PostInitOptions
+
+ SetOption(key, value string) error
+ SetOptionInt(key, value int64) error
+ SetOptionDouble(key, value float64) error
+ GetOptionInt(key string) (int64, error)
+ GetOptionDouble(key string) (float64, error)
+}
diff --git a/go/adbc/infocode_string.go b/go/adbc/infocode_string.go
index 73af20c1..df0fd74b 100644
--- a/go/adbc/infocode_string.go
+++ b/go/adbc/infocode_string.go
@@ -14,23 +14,24 @@ func _() {
_ = x[InfoDriverName-100]
_ = x[InfoDriverVersion-101]
_ = x[InfoDriverArrowVersion-102]
+ _ = x[InfoDriverADBCVersion-103]
}
const (
_InfoCode_name_0 = "VendorNameVendorVersionVendorArrowVersion"
- _InfoCode_name_1 = "DriverNameDriverVersionDriverArrowVersion"
+ _InfoCode_name_1 = "DriverNameDriverVersionDriverArrowVersionDriverADBCVersion"
)
var (
_InfoCode_index_0 = [...]uint8{0, 10, 23, 41}
- _InfoCode_index_1 = [...]uint8{0, 10, 23, 41}
+ _InfoCode_index_1 = [...]uint8{0, 10, 23, 41, 58}
)
func (i InfoCode) String() string {
switch {
case i <= 2:
return _InfoCode_name_0[_InfoCode_index_0[i]:_InfoCode_index_0[i+1]]
- case 100 <= i && i <= 102:
+ case 100 <= i && i <= 103:
i -= 100
return _InfoCode_name_1[_InfoCode_index_1[i]:_InfoCode_index_1[i+1]]
default:
diff --git a/go/adbc/pkg/_tmpl/driver.go.tmpl b/go/adbc/pkg/_tmpl/driver.go.tmpl
index 03a94c02..7ae325a1 100644
--- a/go/adbc/pkg/_tmpl/driver.go.tmpl
+++ b/go/adbc/pkg/_tmpl/driver.go.tmpl
@@ -901,7 +901,7 @@ func {{.Prefix}}DriverInit(version C.int, rawDriver *C.void, err *C.struct_AdbcE
}
driver := (*C.struct_AdbcDriver)(unsafe.Pointer(rawDriver))
- C.memset(unsafe.Pointer(driver), 0, C.sizeof_struct_AdbcDriver)
+ C.memset(unsafe.Pointer(driver), 0, C.ADBC_DRIVER_1_0_0_SIZE)
driver.DatabaseInit = (*[0]byte)(C.{{.Prefix}}DatabaseInit)
driver.DatabaseNew = (*[0]byte)(C.{{.Prefix}}DatabaseNew)
driver.DatabaseRelease = (*[0]byte)(C.{{.Prefix}}DatabaseRelease)
diff --git a/go/adbc/pkg/flightsql/driver.go b/go/adbc/pkg/flightsql/driver.go
index 6d5cf75b..7cbec398 100644
--- a/go/adbc/pkg/flightsql/driver.go
+++ b/go/adbc/pkg/flightsql/driver.go
@@ -905,7 +905,7 @@ func FlightSQLDriverInit(version C.int, rawDriver *C.void, err *C.struct_AdbcErr
}
driver := (*C.struct_AdbcDriver)(unsafe.Pointer(rawDriver))
- C.memset(unsafe.Pointer(driver), 0, C.sizeof_struct_AdbcDriver)
+ C.memset(unsafe.Pointer(driver), 0, C.ADBC_DRIVER_1_0_0_SIZE)
driver.DatabaseInit = (*[0]byte)(C.FlightSQLDatabaseInit)
driver.DatabaseNew = (*[0]byte)(C.FlightSQLDatabaseNew)
driver.DatabaseRelease = (*[0]byte)(C.FlightSQLDatabaseRelease)
diff --git a/go/adbc/pkg/snowflake/driver.go b/go/adbc/pkg/snowflake/driver.go
index 31e2f131..35dc0ce8 100644
--- a/go/adbc/pkg/snowflake/driver.go
+++ b/go/adbc/pkg/snowflake/driver.go
@@ -905,7 +905,7 @@ func SnowflakeDriverInit(version C.int, rawDriver *C.void, err *C.struct_AdbcErr
}
driver := (*C.struct_AdbcDriver)(unsafe.Pointer(rawDriver))
- C.memset(unsafe.Pointer(driver), 0, C.sizeof_struct_AdbcDriver)
+ C.memset(unsafe.Pointer(driver), 0, C.ADBC_DRIVER_1_0_0_SIZE)
driver.DatabaseInit = (*[0]byte)(C.SnowflakeDatabaseInit)
driver.DatabaseNew = (*[0]byte)(C.SnowflakeDatabaseNew)
driver.DatabaseRelease = (*[0]byte)(C.SnowflakeDatabaseRelease)
diff --git a/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcConnection.java b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcConnection.java
index fea70548..d3c81191 100644
--- a/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcConnection.java
+++ b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcConnection.java
@@ -27,7 +27,7 @@ import org.apache.arrow.vector.types.pojo.Schema;
* <p>Connections are not required to be thread-safe, but they can be used from multiple threads so
* long as clients take care to serialize accesses to a connection.
*/
-public interface AdbcConnection extends AutoCloseable {
+public interface AdbcConnection extends AutoCloseable, AdbcOptions {
/** Commit the pending transaction. */
default void commit() throws AdbcException {
throw AdbcException.notImplemented("Connection does not support transactions");
@@ -285,6 +285,42 @@ public interface AdbcConnection extends AutoCloseable {
throw AdbcException.notImplemented("Connection does not support transactions");
}
+ /**
+ * Get the current catalog.
+ *
+ * @since ADBC API revision 1.1.0
+ */
+ default String getCurrentCatalog() throws AdbcException {
+ throw AdbcException.notImplemented("Connection does not support current catalog");
+ }
+
+ /**
+ * Set the current catalog.
+ *
+ * @since ADBC API revision 1.1.0
+ */
+ default void setCurrentCatalog(String catalog) throws AdbcException {
+ throw AdbcException.notImplemented("Connection does not support current catalog");
+ }
+
+ /**
+ * Get the current schema.
+ *
+ * @since ADBC API revision 1.1.0
+ */
+ default String getCurrentDbSchema() throws AdbcException {
+ throw AdbcException.notImplemented("Connection does not support current catalog");
+ }
+
+ /**
+ * Set the current schema.
+ *
+ * @since ADBC API revision 1.1.0
+ */
+ default void setCurrentDbSchema(String catalog) throws AdbcException {
+ throw AdbcException.notImplemented("Connection does not support current catalog");
+ }
+
/**
* Get whether the connection is read-only.
*
diff --git a/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcDatabase.java b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcDatabase.java
index e63c598b..723acfc0 100644
--- a/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcDatabase.java
+++ b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcDatabase.java
@@ -24,7 +24,7 @@ package org.apache.arrow.adbc.core;
* remote/networked databases, for in-memory databases, this object provides an explicit point of
* ownership.
*/
-public interface AdbcDatabase extends AutoCloseable {
+public interface AdbcDatabase extends AutoCloseable, AdbcOptions {
/** Create a new connection to the database. */
AdbcConnection connect() throws AdbcException;
}
diff --git a/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcDriver.java b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcDriver.java
index 80abd185..9386b880 100644
--- a/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcDriver.java
+++ b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcDriver.java
@@ -21,11 +21,42 @@ import java.util.Map;
/** A handle to an ADBC database driver. */
public interface AdbcDriver {
- /** The standard parameter name for a connection URL (type String). */
- String PARAM_URL = "adbc.url";
+ /**
+ * The standard parameter name for a password (type String).
+ *
+ * @since ADBC API revision 1.1.0
+ */
+ AdbcOptionKey<String> PARAM_PASSWORD = new AdbcOptionKey<>("password", String.class);
+
+ /**
+ * The standard parameter name for a connection URI (type String).
+ *
+ * @since ADBC API revision 1.1.0
+ */
+ AdbcOptionKey<String> PARAM_URI = new AdbcOptionKey<>("uri", String.class);
+
+ /**
+ * The standard parameter name for a connection URL (type String).
+ *
+ * @deprecated Prefer {@link #PARAM_URI} instead.
+ */
+ @Deprecated String PARAM_URL = "adbc.url";
+
+ /**
+ * The standard parameter name for a username (type String).
+ *
+ * @since ADBC API revision 1.1.0
+ */
+ AdbcOptionKey<String> PARAM_USERNAME = new AdbcOptionKey<>("username", String.class);
+
/** The standard parameter name for SQL quirks configuration (type SqlQuirks). */
String PARAM_SQL_QUIRKS = "adbc.sql.quirks";
+ /** ADBC API revision 1.0.0. */
+ long ADBC_VERSION_1_0_0 = 1_000_000;
+ /** ADBC API revision 1.1.0. */
+ long ADBC_VERSION_1_1_0 = 1_001_000;
+
/**
* Open a database via this driver.
*
diff --git a/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcInfoCode.java b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcInfoCode.java
index 52c09565..8d5c73ba 100644
--- a/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcInfoCode.java
+++ b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcInfoCode.java
@@ -16,7 +16,12 @@
*/
package org.apache.arrow.adbc.core;
-/** Integer IDs used for requesting information about the database/driver. */
+/**
+ * Integer IDs used for requesting information about the database/driver.
+ *
+ * <p>Since ADBC 1.1.0: the range [500, 1_000) is reserved for "XDBC" information, which is the same
+ * metadata provided by the same info code range in the Arrow Flight SQL GetSqlInfo RPC.
+ */
public enum AdbcInfoCode {
/** The database vendor/product name (e.g. the server name) (type: utf8). */
VENDOR_NAME(0),
@@ -31,6 +36,16 @@ public enum AdbcInfoCode {
DRIVER_VERSION(101),
/** The driver Arrow library version (type: utf8). */
DRIVER_ARROW_VERSION(102),
+ /**
+ * The ADBC API version (type: int64).
+ *
+ * <p>The value should be one of the ADBC_VERSION constants.
+ *
+ * @see AdbcDriver#ADBC_VERSION_1_0_0
+ * @see AdbcDriver#ADBC_VERSION_1_1_0
+ * @since ADBC API revision 1.1.0
+ */
+ DRIVER_ADBC_VERSION(103),
;
private final int value;
diff --git a/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcOptionKey.java b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcOptionKey.java
new file mode 100644
index 00000000..d5947036
--- /dev/null
+++ b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcOptionKey.java
@@ -0,0 +1,69 @@
+/*
+ * 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.
+ */
+
+package org.apache.arrow.adbc.core;
+
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * A typesafe option key.
+ *
+ * @since ADBC API revision 1.1.0
+ * @param <T> The option value type.
+ */
+public final class AdbcOptionKey<T> {
+ private final String key;
+ private final Class<T> type;
+
+ public AdbcOptionKey(String key, Class<T> type) {
+ this.key = Objects.requireNonNull(key);
+ this.type = Objects.requireNonNull(type);
+ }
+
+ /**
+ * Set this option in an options map (like for {@link AdbcDriver#open(Map)}.
+ *
+ * @param options The options.
+ * @param value The option value.
+ */
+ public void set(Map<String, Object> options, T value) {
+ options.put(key, value);
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+ AdbcOptionKey<?> that = (AdbcOptionKey<?>) o;
+ return Objects.equals(key, that.key) && Objects.equals(type, that.type);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(key, type);
+ }
+
+ @Override
+ public String toString() {
+ return "AdbcOptionKey{" + key + ", " + type + '}';
+ }
+}
diff --git a/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcDriver.java b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcOptions.java
similarity index 52%
copy from java/core/src/main/java/org/apache/arrow/adbc/core/AdbcDriver.java
copy to java/core/src/main/java/org/apache/arrow/adbc/core/AdbcOptions.java
index 80abd185..efd8eab7 100644
--- a/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcDriver.java
+++ b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcOptions.java
@@ -17,19 +17,29 @@
package org.apache.arrow.adbc.core;
-import java.util.Map;
-
-/** A handle to an ADBC database driver. */
-public interface AdbcDriver {
- /** The standard parameter name for a connection URL (type String). */
- String PARAM_URL = "adbc.url";
- /** The standard parameter name for SQL quirks configuration (type SqlQuirks). */
- String PARAM_SQL_QUIRKS = "adbc.sql.quirks";
+/** An ADBC object that supports getting/setting generic options. */
+public interface AdbcOptions {
+ /**
+ * Get a generic option.
+ *
+ * @since ADBC API revision 1.1.0
+ * @param key The option to retrieve.
+ * @return The option value.
+ * @param <T> The option value type.
+ */
+ default <T> T getOption(AdbcOptionKey<T> key) throws AdbcException {
+ throw AdbcException.notImplemented("Unsupported option " + key);
+ }
/**
- * Open a database via this driver.
+ * Set a generic option.
*
- * @param parameters Driver-specific parameters.
+ * @since ADBC API revision 1.1.0
+ * @param key The option to set.
+ * @param value The option value.
+ * @param <T> The option value type.
*/
- AdbcDatabase open(Map<String, Object> parameters) throws AdbcException;
+ default <T> void setOption(AdbcOptionKey<T> key, T value) throws AdbcException {
+ throw AdbcException.notImplemented("Unsupported option " + key);
+ }
}
diff --git a/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcStatement.java b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcStatement.java
index ef2be487..a033726b 100644
--- a/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcStatement.java
+++ b/java/core/src/main/java/org/apache/arrow/adbc/core/AdbcStatement.java
@@ -19,6 +19,7 @@ package org.apache.arrow.adbc.core;
import java.io.IOException;
import java.nio.ByteBuffer;
+import java.util.Iterator;
import java.util.List;
import org.apache.arrow.vector.VectorSchemaRoot;
import org.apache.arrow.vector.ipc.ArrowReader;
@@ -40,8 +41,23 @@ import org.apache.arrow.vector.types.pojo.Schema;
* <p>Statements are not required to be thread-safe, but they can be used from multiple threads so
* long as clients take care to serialize accesses to a statement.
*/
-public interface AdbcStatement extends AutoCloseable {
- /** Set a generic query option. */
+public interface AdbcStatement extends AutoCloseable, AdbcOptions {
+ /**
+ * Cancel execution of a query.
+ *
+ * <p>This method must be thread-safe (other method are not necessarily thread-safe).
+ *
+ * @since ADBC API revision 1.1.0
+ */
+ default void cancel() throws AdbcException {
+ throw AdbcException.notImplemented("Statement does not support cancel");
+ }
+
+ /**
+ * Set a generic query option.
+ *
+ * @deprecated Prefer {@link #setOption(AdbcOptionKey, Object)}.
+ */
default void setOption(String key, Object value) throws AdbcException {
throw AdbcException.notImplemented("Unsupported option " + key);
}
@@ -94,6 +110,37 @@ public interface AdbcStatement extends AutoCloseable {
throw AdbcException.notImplemented("Statement does not support executePartitioned");
}
+ /**
+ * Get the schema of the result set without executing the query.
+ *
+ * @since ADBC API revision 1.1.0
+ */
+ default Schema executeSchema() throws AdbcException {
+ throw AdbcException.notImplemented("Statement does not support executeSchema");
+ }
+
+ /**
+ * Execute a result set-generating query and get a list of partitions of the result set.
+ *
+ * <p>These can be serialized and deserialized for parallel and/or distributed fetching.
+ *
+ * <p>This may invalidate any prior result sets.
+ *
+ * @since ADBC API revision 1.1.0
+ */
+ default Iterator<PartitionResult> pollPartitioned() throws AdbcException {
+ throw AdbcException.notImplemented("Statement does not support pollPartitioned");
+ }
+
+ /**
+ * Get the progress of executing a query.
+ *
+ * @since ADBC API revision 1.1.0
+ */
+ default double getProgress() throws AdbcException {
+ throw AdbcException.notImplemented("Statement does not support getProgress");
+ }
+
/**
* Get the schema for bound parameters.
*
diff --git a/java/core/src/main/java/org/apache/arrow/adbc/core/BulkIngestMode.java b/java/core/src/main/java/org/apache/arrow/adbc/core/BulkIngestMode.java
index 2ab16ac4..e23e8de4 100644
--- a/java/core/src/main/java/org/apache/arrow/adbc/core/BulkIngestMode.java
+++ b/java/core/src/main/java/org/apache/arrow/adbc/core/BulkIngestMode.java
@@ -24,7 +24,20 @@ public enum BulkIngestMode {
/**
* Do not create the table and append data; error if the table does not exist ({@link
* AdbcStatusCode#NOT_FOUND}) or does not match the schema of the data to append ({@link
- * AdbcStatusCode#ALREADY_EXISTS}). *
+ * AdbcStatusCode#ALREADY_EXISTS}).
*/
APPEND,
+ /**
+ * Create the table and insert data; drop the original table if it already exists.
+ *
+ * @since ADBC API revision 1.1.0
+ */
+ REPLACE,
+ /**
+ * Insert data; create the table if it does not exist, or error ({@link
+ * AdbcStatusCode#ALREADY_EXISTS}) if the table exists, but the schema does not match the schema
+ * of the data to append.
+ */
+ CREATE_APPEND,
+ ;
}
[arrow-adbc] 02/03: feat(format): remove unnecessary padding (#731)
Posted by li...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
lidavidm pushed a commit to branch spec-1.1.0
in repository https://gitbox.apache.org/repos/asf/arrow-adbc.git
commit 7f920bf7d81acd5090bd7f39765e2d64c6cde609
Author: David Li <li...@gmail.com>
AuthorDate: Tue Jun 6 14:28:48 2023 -0400
feat(format): remove unnecessary padding (#731)
- Clarify one of the docstrings
- Remove the 'future growth' padding since we have a different
compatibility strategy
---
adbc.h | 5 +----
c/driver_manager/adbc_driver_manager.cc | 3 ---
c/driver_manager/adbc_driver_manager_test.cc | 2 --
3 files changed, 1 insertion(+), 9 deletions(-)
diff --git a/adbc.h b/adbc.h
index 756288da..5118f830 100644
--- a/adbc.h
+++ b/adbc.h
@@ -799,7 +799,7 @@ struct ADBC_EXPORT AdbcDriver {
/// and attempt to have the driver initialize it with
/// ADBC_VERSION_1_1_0. This must return an error, after which the
/// driver will try again with ADBC_VERSION_1_0_0. The driver must
- /// not access the new fields.
+ /// not access the new fields, which will carry undefined values.
///
/// For a 1.1.0 driver being loaded by a 1.0.0 driver manager: the
/// 1.0.0 manager will allocate the old AdbcDriver struct and
@@ -845,9 +845,6 @@ struct ADBC_EXPORT AdbcDriver {
AdbcStatusCode (*StatementSetOptionDouble)(struct AdbcStatement*, const char*, double,
struct AdbcError*);
- /// Pad the struct to have 96 pointers. Space reserved for future growth.
- void* reserved[50];
-
/// @}
};
diff --git a/c/driver_manager/adbc_driver_manager.cc b/c/driver_manager/adbc_driver_manager.cc
index 888c48a6..4ad77f2e 100644
--- a/c/driver_manager/adbc_driver_manager.cc
+++ b/c/driver_manager/adbc_driver_manager.cc
@@ -870,9 +870,6 @@ AdbcStatusCode AdbcLoadDriverFromInitFunc(AdbcDriverInitFunc init_func, int vers
if (version >= ADBC_VERSION_1_1_0) {
auto* driver = reinterpret_cast<struct AdbcDriver*>(raw_driver);
FILL_DEFAULT(driver, StatementExecuteSchema);
-
- // Zero out the padding
- std::memset(driver->reserved, 0, sizeof(driver->reserved));
}
return ADBC_STATUS_OK;
diff --git a/c/driver_manager/adbc_driver_manager_test.cc b/c/driver_manager/adbc_driver_manager_test.cc
index 26c8dc61..97743e70 100644
--- a/c/driver_manager/adbc_driver_manager_test.cc
+++ b/c/driver_manager/adbc_driver_manager_test.cc
@@ -34,8 +34,6 @@ namespace adbc {
using adbc_validation::IsOkStatus;
using adbc_validation::IsStatus;
-TEST(Adbc, AdbcDriverSize) { ASSERT_EQ(sizeof(AdbcDriver), 96 * sizeof(void*)); }
-
class DriverManager : public ::testing::Test {
public:
void SetUp() override {