This is an automated email from the ASF dual-hosted git repository.
lidavidm pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-adbc.git
The following commit(s) were added to refs/heads/main by this push:
new c8826f560 build(c): work around clang making `__COUNTER__` a warning
(#4044)
c8826f560 is described below
commit c8826f56030f11489bc1adf5aaaa773f37151654
Author: David Li <[email protected]>
AuthorDate: Mon Mar 9 08:48:38 2026 +0900
build(c): work around clang making `__COUNTER__` a warning (#4044)
Closes #4042.
---
c/driver/framework/base_driver.h | 9 ++-
c/driver/framework/connection.h | 18 +++--
c/driver/framework/objects.cc | 15 ++--
c/driver/framework/statement.h | 18 +++--
c/driver/framework/status.h | 103 ++++++++++++++----------
c/driver/postgresql/connection.cc | 3 +-
c/driver/postgresql/database.cc | 15 ++--
c/driver/sqlite/sqlite.cc | 45 +++++++----
c/vendor/nanoarrow/nanoarrow.h | 24 ++++--
c/vendor/nanoarrow/nanoarrow.hpp | 6 +-
c/vendor/vendor_nanoarrow.sh | 2 +-
docs/source/cpp/recipe_driver/driver_example.cc | 5 +-
12 files changed, 166 insertions(+), 97 deletions(-)
diff --git a/c/driver/framework/base_driver.h b/c/driver/framework/base_driver.h
index f379121b6..bebdffea6 100644
--- a/c/driver/framework/base_driver.h
+++ b/c/driver/framework/base_driver.h
@@ -325,13 +325,15 @@ class ObjectBase {
template <typename T>
AdbcStatusCode CGetOptionStringLike(const char* key, T* value, size_t*
length,
AdbcError* error) {
- RAISE_RESULT(error, auto option, GetOption(key));
+ Option option;
+ RAISE_RESULT(error, option, GetOption(key));
return option.CGet(value, length, error);
}
template <typename T>
AdbcStatusCode CGetOptionNumeric(const char* key, T* value, AdbcError*
error) {
- RAISE_RESULT(error, auto option, GetOption(key));
+ Option option;
+ RAISE_RESULT(error, option, GetOption(key));
return option.CGet(value, error);
}
};
@@ -1057,7 +1059,8 @@ class BaseStatement : public ObjectBase {
AdbcStatusCode ExecuteQuery(ArrowArrayStream* stream, int64_t* rows_affected,
AdbcError* error) {
- RAISE_RESULT(error, int64_t rows_affected_result,
impl().ExecuteQueryImpl(stream));
+ int64_t rows_affected_result;
+ RAISE_RESULT(error, rows_affected_result, impl().ExecuteQueryImpl(stream));
if (rows_affected) {
*rows_affected = rows_affected_result;
}
diff --git a/c/driver/framework/connection.h b/c/driver/framework/connection.h
index da3aae107..783dc8046 100644
--- a/c/driver/framework/connection.h
+++ b/c/driver/framework/connection.h
@@ -85,7 +85,8 @@ class Connection : public ObjectBase {
}
std::vector<uint32_t> codes(info_codes, info_codes + info_codes_length);
- RAISE_RESULT(error, auto infos, impl().InfoImpl(codes));
+ std::vector<InfoValue> infos;
+ RAISE_RESULT(error, infos, impl().InfoImpl(codes));
RAISE_STATUS(error, MakeGetInfoStream(infos, out));
return ADBC_STATUS_OK;
}
@@ -131,7 +132,8 @@ class Connection : public ObjectBase {
.ToAdbc(error);
}
- RAISE_RESULT(error, auto helper, impl().GetObjectsImpl());
+ std::unique_ptr<GetObjectsHelper> helper;
+ RAISE_RESULT(error, helper, impl().GetObjectsImpl());
auto status = BuildGetObjects(helper.get(), depth, catalog_filter,
schema_filter,
table_filter, column_filter,
table_type_filter, out);
RAISE_STATUS(error, helper->Close());
@@ -149,13 +151,15 @@ class Connection : public ObjectBase {
return driver::Option(ADBC_OPTION_VALUE_DISABLED);
}
} else if (key == ADBC_CONNECTION_OPTION_CURRENT_CATALOG) {
- UNWRAP_RESULT(auto catalog, impl().GetCurrentCatalogImpl());
+ std::optional<std::string> catalog;
+ UNWRAP_RESULT(catalog, impl().GetCurrentCatalogImpl());
if (catalog) {
return driver::Option(std::move(*catalog));
}
return driver::Option();
} else if (key == ADBC_CONNECTION_OPTION_CURRENT_DB_SCHEMA) {
- UNWRAP_RESULT(auto schema, impl().GetCurrentSchemaImpl());
+ std::optional<std::string> schema;
+ UNWRAP_RESULT(schema, impl().GetCurrentSchemaImpl());
if (schema) {
return driver::Option(std::move(*schema));
}
@@ -203,7 +207,8 @@ class Connection : public ObjectBase {
RAISE_STATUS(error, status::InvalidArgument("out must be non-null"));
}
- RAISE_RESULT(error, std::vector<std::string> table_types,
impl().GetTableTypesImpl());
+ std::vector<std::string> table_types;
+ RAISE_RESULT(error, table_types, impl().GetTableTypesImpl());
RAISE_STATUS(error, MakeTableTypesStream(table_types, out));
return ADBC_STATUS_OK;
}
@@ -281,7 +286,8 @@ class Connection : public ObjectBase {
Status SetOptionImpl(std::string_view key, Option value) {
if (key == ADBC_CONNECTION_OPTION_AUTOCOMMIT) {
- UNWRAP_RESULT(auto enabled, value.AsBool());
+ bool enabled;
+ UNWRAP_RESULT(enabled, value.AsBool());
switch (autocommit_) {
case AutocommitState::kAutocommit: {
if (!enabled) {
diff --git a/c/driver/framework/objects.cc b/c/driver/framework/objects.cc
index 31197c2d3..e4ad7673b 100644
--- a/c/driver/framework/objects.cc
+++ b/c/driver/framework/objects.cc
@@ -287,7 +287,8 @@ struct GetObjectsBuilder {
Status AppendCatalogs() {
UNWRAP_STATUS(helper->LoadCatalogs(catalog_filter));
while (true) {
- UNWRAP_RESULT(auto maybe_catalog, helper->NextCatalog());
+ std::optional<std::string_view> maybe_catalog;
+ UNWRAP_RESULT(maybe_catalog, helper->NextCatalog());
if (!maybe_catalog.has_value()) break;
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(catalog_name_col,
@@ -305,7 +306,8 @@ struct GetObjectsBuilder {
Status AppendSchemas(std::string_view catalog) {
UNWRAP_STATUS(helper->LoadSchemas(catalog, schema_filter));
while (true) {
- UNWRAP_RESULT(auto maybe_schema, helper->NextSchema());
+ std::optional<std::string_view> maybe_schema;
+ UNWRAP_RESULT(maybe_schema, helper->NextSchema());
if (!maybe_schema.has_value()) break;
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(db_schema_name_col,
@@ -326,7 +328,8 @@ struct GetObjectsBuilder {
Status AppendTables(std::string_view catalog, std::string_view schema) {
UNWRAP_STATUS(helper->LoadTables(catalog, schema, table_filter,
table_types));
while (true) {
- UNWRAP_RESULT(auto maybe_table, helper->NextTable());
+ std::optional<GetObjectsHelper::Table> maybe_table;
+ UNWRAP_RESULT(maybe_table, helper->NextTable());
if (!maybe_table.has_value()) break;
UNWRAP_ERRNO(Internal, ArrowArrayAppendString(table_name_col,
@@ -351,7 +354,8 @@ struct GetObjectsBuilder {
std::string_view table) {
UNWRAP_STATUS(helper->LoadColumns(catalog, schema, table, column_filter));
while (true) {
- UNWRAP_RESULT(auto maybe_column, helper->NextColumn());
+ std::optional<GetObjectsHelper::Column> maybe_column;
+ UNWRAP_RESULT(maybe_column, helper->NextColumn());
if (!maybe_column.has_value()) break;
const auto& column = *maybe_column;
@@ -415,7 +419,8 @@ struct GetObjectsBuilder {
Status AppendConstraints(std::string_view catalog, std::string_view schema,
std::string_view table) {
while (true) {
- UNWRAP_RESULT(auto maybe_constraint, helper->NextConstraint());
+ std::optional<GetObjectsHelper::Constraint> maybe_constraint;
+ UNWRAP_RESULT(maybe_constraint, helper->NextConstraint());
if (!maybe_constraint.has_value()) break;
// XXX: copy to make gcc 12.2's -Wmaybe-uninitialized happy (only
// happens with optimizations enabled)
diff --git a/c/driver/framework/statement.h b/c/driver/framework/statement.h
index c07324849..4a1a2cb21 100644
--- a/c/driver/framework/statement.h
+++ b/c/driver/framework/statement.h
@@ -128,7 +128,8 @@ class Statement : public BaseStatement<Derived> {
" Cannot ingest with result set")
.ToAdbc(error);
}
- RAISE_RESULT(error, int64_t rows, impl().ExecuteIngestImpl(state));
+ int64_t rows;
+ RAISE_RESULT(error, rows, impl().ExecuteIngestImpl(state));
if (rows_affected) {
*rows_affected = rows;
}
@@ -234,7 +235,8 @@ class Statement : public BaseStatement<Derived> {
return std::get<IngestState>(state_);
};
if (key == ADBC_INGEST_OPTION_MODE) {
- RAISE_RESULT(error, auto mode, value.AsString());
+ std::string_view mode;
+ RAISE_RESULT(error, mode, value.AsString());
if (mode == ADBC_INGEST_OPTION_MODE_APPEND) {
auto& state = ensure_ingest();
state.table_does_not_exist_ = TableDoesNotExist::kFail;
@@ -259,7 +261,8 @@ class Statement : public BaseStatement<Derived> {
return ADBC_STATUS_OK;
} else if (key == ADBC_INGEST_OPTION_TARGET_CATALOG) {
if (value.has_value()) {
- RAISE_RESULT(error, auto catalog, value.AsString());
+ std::string_view catalog;
+ RAISE_RESULT(error, catalog, value.AsString());
ensure_ingest().target_catalog = catalog;
} else {
ensure_ingest().target_catalog = std::nullopt;
@@ -267,18 +270,21 @@ class Statement : public BaseStatement<Derived> {
return ADBC_STATUS_OK;
} else if (key == ADBC_INGEST_OPTION_TARGET_DB_SCHEMA) {
if (value.has_value()) {
- RAISE_RESULT(error, auto schema, value.AsString());
+ std::string_view schema;
+ RAISE_RESULT(error, schema, value.AsString());
ensure_ingest().target_schema = schema;
} else {
ensure_ingest().target_schema = std::nullopt;
}
return ADBC_STATUS_OK;
} else if (key == ADBC_INGEST_OPTION_TARGET_TABLE) {
- RAISE_RESULT(error, auto table, value.AsString());
+ std::string_view table;
+ RAISE_RESULT(error, table, value.AsString());
ensure_ingest().target_table = table;
return ADBC_STATUS_OK;
} else if (key == ADBC_INGEST_OPTION_TEMPORARY) {
- RAISE_RESULT(error, auto temporary, value.AsBool());
+ bool temporary;
+ RAISE_RESULT(error, temporary, value.AsBool());
ensure_ingest().temporary = temporary;
return ADBC_STATUS_OK;
}
diff --git a/c/driver/framework/status.h b/c/driver/framework/status.h
index 22e484dd3..69893ae44 100644
--- a/c/driver/framework/status.h
+++ b/c/driver/framework/status.h
@@ -244,47 +244,59 @@ class Result {
std::variant<Status, T> value_;
};
+#define RESULT_NAME_SUFFIX _adbc_framework_result
#define RAISE_RESULT_IMPL(NAME, ERROR, LHS, RHS) \
- auto&& NAME = (RHS); \
- if (!(NAME).has_value()) { \
- return (NAME).status().ToAdbc(ERROR); \
- } \
- LHS = std::move((NAME).value());
+ do { \
+ auto&& NAME = (RHS); \
+ if (!(NAME).has_value()) { \
+ return (NAME).status().ToAdbc(ERROR); \
+ } \
+ LHS = std::move((NAME).value()); \
+ } while (0);
#define RAISE_STATUS_IMPL(NAME, ERROR, RHS) \
- auto&& NAME = (RHS); \
- if (!(NAME).ok()) { \
- return (NAME).ToAdbc(ERROR); \
- }
+ do { \
+ auto&& NAME = (RHS); \
+ if (!(NAME).ok()) { \
+ return (NAME).ToAdbc(ERROR); \
+ } \
+ } while (0);
#define UNWRAP_RESULT_IMPL(name, lhs, rhs) \
- auto&& name = (rhs); \
- if (!(name).has_value()) { \
- return std::move(name).status(); \
- } \
- lhs = std::move((name).value());
+ do { \
+ auto&& name = (rhs); \
+ if (!(name).has_value()) { \
+ return std::move(name).status(); \
+ } \
+ lhs = std::move((name).value()); \
+ } while (0);
#define UNWRAP_STATUS_IMPL(name, rhs) \
- auto&& name = (rhs); \
- if (!(name).ok()) { \
- return std::move(name); \
- }
+ do { \
+ auto&& name = (rhs); \
+ if (!(name).ok()) { \
+ return std::move(name); \
+ } \
+ } while (0);
#define DRIVER_CONCAT(x, y) x##y
#define UNWRAP_RESULT_NAME(x, y) DRIVER_CONCAT(x, y)
/// \brief A helper to unwrap a Result in functions returning AdbcStatusCode.
-#define RAISE_RESULT(ERROR, LHS, RHS) \
- RAISE_RESULT_IMPL(UNWRAP_RESULT_NAME(driver_raise_result, __COUNTER__),
ERROR, LHS, RHS)
+#define RAISE_RESULT(ERROR, LHS, RHS)
\
+ RAISE_RESULT_IMPL(UNWRAP_RESULT_NAME(driver_raise_result,
RESULT_NAME_SUFFIX), ERROR, \
+ LHS, RHS)
/// \brief A helper to unwrap a Status in functions returning AdbcStatusCode.
-#define RAISE_STATUS(ERROR, RHS) \
- RAISE_STATUS_IMPL(UNWRAP_RESULT_NAME(driver_raise_status, __COUNTER__),
ERROR, RHS)
+#define RAISE_STATUS(ERROR, RHS)
\
+ RAISE_STATUS_IMPL(UNWRAP_RESULT_NAME(driver_raise_status,
RESULT_NAME_SUFFIX), ERROR, \
+ RHS)
/// \brief A helper to unwrap a Result in functions returning Result/Status.
-#define UNWRAP_RESULT(lhs, rhs) \
- UNWRAP_RESULT_IMPL(UNWRAP_RESULT_NAME(driver_unwrap_result, __COUNTER__),
lhs, rhs)
+#define UNWRAP_RESULT(lhs, rhs)
\
+ UNWRAP_RESULT_IMPL(UNWRAP_RESULT_NAME(driver_unwrap_result,
RESULT_NAME_SUFFIX), lhs, \
+ rhs)
/// \brief A helper to unwrap a Status in functions returning Result/Status.
#define UNWRAP_STATUS(rhs) \
- UNWRAP_STATUS_IMPL(UNWRAP_RESULT_NAME(driver_unwrap_status, __COUNTER__),
rhs)
+ UNWRAP_STATUS_IMPL(UNWRAP_RESULT_NAME(driver_unwrap_status,
RESULT_NAME_SUFFIX), rhs)
} // namespace adbc::driver
@@ -337,23 +349,28 @@ STATUS_CTOR(Unknown, UNKNOWN)
} // namespace adbc::driver::status::fmt
#endif
-#define UNWRAP_ERRNO_IMPL(NAME, CODE, RHS)
\
- auto&& NAME = (RHS);
\
- if (NAME != 0) {
\
- return adbc::driver::status::CODE("Call failed: ", #RHS, " = (errno ",
NAME, ") ", \
- std::strerror(NAME));
\
- }
+#define UNWRAP_ERRNO_IMPL(NAME, CODE, RHS)
\
+ do {
\
+ auto&& NAME = (RHS);
\
+ if (NAME != 0) {
\
+ return adbc::driver::status::CODE("Call failed: ", #RHS, " = (errno ",
NAME, ") ", \
+ std::strerror(NAME));
\
+ }
\
+ } while (0);
#define UNWRAP_ERRNO(CODE, RHS) \
- UNWRAP_ERRNO_IMPL(UNWRAP_RESULT_NAME(driver_errno, __COUNTER__), CODE, RHS)
-
-#define UNWRAP_NANOARROW_IMPL(NAME, ERROR, CODE, RHS)
\
- auto&& NAME = (RHS);
\
- if (NAME != 0) {
\
- return adbc::driver::status::CODE("nanoarrow call failed: ", #RHS, " = (",
NAME, \
- ") ", std::strerror(NAME), ". ",
(ERROR).message); \
- }
-
-#define UNWRAP_NANOARROW(ERROR, CODE, RHS)
\
- UNWRAP_NANOARROW_IMPL(UNWRAP_RESULT_NAME(driver_errno_na, __COUNTER__),
ERROR, CODE, \
- RHS)
+ UNWRAP_ERRNO_IMPL(UNWRAP_RESULT_NAME(driver_errno, RESULT_NAME_SUFFIX),
CODE, RHS)
+
+#define UNWRAP_NANOARROW_IMPL(NAME, ERROR, CODE, RHS)
\
+ do {
\
+ auto&& NAME = (RHS);
\
+ if (NAME != 0) {
\
+ return adbc::driver::status::CODE("nanoarrow call failed: ", #RHS, " =
(", NAME, \
+ ") ", std::strerror(NAME), ". ",
\
+ (ERROR).message);
\
+ }
\
+ } while (0);
+
+#define UNWRAP_NANOARROW(ERROR, CODE, RHS)
\
+ UNWRAP_NANOARROW_IMPL(UNWRAP_RESULT_NAME(driver_errno_na,
RESULT_NAME_SUFFIX), ERROR, \
+ CODE, RHS)
diff --git a/c/driver/postgresql/connection.cc
b/c/driver/postgresql/connection.cc
index da7fdeac9..1816586cc 100644
--- a/c/driver/postgresql/connection.cc
+++ b/c/driver/postgresql/connection.cc
@@ -311,7 +311,8 @@ class PostgresGetObjectsHelper : public
adbc::driver::GetObjectsHelper {
Column col;
col.column_name = next_column_[0].value();
- UNWRAP_RESULT(int64_t ordinal_position, next_column_[1].ParseInteger());
+ int64_t ordinal_position;
+ UNWRAP_RESULT(ordinal_position, next_column_[1].ParseInteger());
col.ordinal_position = static_cast<int32_t>(ordinal_position);
if (!next_column_[2].is_null) {
col.remarks = next_column_[2].value();
diff --git a/c/driver/postgresql/database.cc b/c/driver/postgresql/database.cc
index bf488067c..d3daa18e8 100644
--- a/c/driver/postgresql/database.cc
+++ b/c/driver/postgresql/database.cc
@@ -297,9 +297,11 @@ static Status InsertPgAttributeResult(
for (int row = 0; row < num_rows; row++) {
PqResultRow item = result.Row(row);
- UNWRAP_RESULT(int64_t type_oid, item[0].ParseInteger());
+ int64_t type_oid;
+ UNWRAP_RESULT(type_oid, item[0].ParseInteger());
std::string_view col_name = item[1].value();
- UNWRAP_RESULT(int64_t col_oid, item[2].ParseInteger());
+ int64_t col_oid;
+ UNWRAP_RESULT(col_oid, item[2].ParseInteger());
if (type_oid != current_type_oid && !columns.empty()) {
resolver->InsertClass(static_cast<uint32_t>(current_type_oid), columns);
@@ -331,11 +333,14 @@ static Status InsertPgTypeResult(const PqResultHelper&
result,
for (int row = 0; row < num_rows; row++) {
PqResultRow item = result.Row(row);
- UNWRAP_RESULT(int64_t oid, item[0].ParseInteger());
+ int64_t oid;
+ UNWRAP_RESULT(oid, item[0].ParseInteger());
const char* typname = item[1].data;
const char* typreceive = item[2].data;
- UNWRAP_RESULT(int64_t typbasetype, item[3].ParseInteger());
- UNWRAP_RESULT(int64_t typrelid, item[4].ParseInteger());
+ int64_t typbasetype;
+ UNWRAP_RESULT(typbasetype, item[3].ParseInteger());
+ int64_t typrelid;
+ UNWRAP_RESULT(typrelid, item[4].ParseInteger());
int64_t typarray;
if (num_cols == 6) {
diff --git a/c/driver/sqlite/sqlite.cc b/c/driver/sqlite/sqlite.cc
index 58f9dd1dc..c2a1ae798 100644
--- a/c/driver/sqlite/sqlite.cc
+++ b/c/driver/sqlite/sqlite.cc
@@ -178,8 +178,9 @@ class SqliteQuery {
static Status Execute(sqlite3* conn, std::string_view query) {
SqliteQuery q(conn, query);
UNWRAP_STATUS(q.Init());
+ bool has_row;
while (true) {
- UNWRAP_RESULT(bool has_row, q.Next());
+ UNWRAP_RESULT(has_row, q.Next());
if (!has_row) break;
}
return q.Close();
@@ -194,8 +195,9 @@ class SqliteQuery {
int rc = std::forward<BindFunc>(bind_func)(q.stmt_);
if (rc != SQLITE_OK) return q.Close();
+ bool has_row;
while (true) {
- UNWRAP_RESULT(bool has_row, q.Next());
+ UNWRAP_RESULT(has_row, q.Next());
if (!has_row) break;
rc = std::forward<RowFunc>(row_func)(q.stmt_);
@@ -290,7 +292,8 @@ struct SqliteGetObjectsHelper : public
driver::GetObjectsHelper {
}
builder.Append(" )");
}
- UNWRAP_RESULT(auto query, builder.GetString());
+ std::string_view query;
+ UNWRAP_RESULT(query, builder.GetString());
return SqliteQuery::Scan(
conn, query,
@@ -320,7 +323,8 @@ struct SqliteGetObjectsHelper : public
driver::GetObjectsHelper {
columns_query.Append(
R"(SELECT cid, name, type, 'notnull', dflt_value FROM
pragma_table_info(%Q, %Q) WHERE NAME LIKE ?)",
table.data(), catalog.data());
- UNWRAP_RESULT(auto query, columns_query.GetString());
+ std::string_view query;
+ UNWRAP_RESULT(query, columns_query.GetString());
assert(!query.empty());
columns.emplace(conn, query);
@@ -351,7 +355,8 @@ struct SqliteGetObjectsHelper : public
driver::GetObjectsHelper {
builder.Append(
R"(SELECT name FROM pragma_table_info(%Q, %Q) WHERE pk > 0 ORDER BY
pk ASC)",
table.data(), catalog.data());
- UNWRAP_RESULT(auto pk_query, builder.GetString());
+ std::string_view pk_query;
+ UNWRAP_RESULT(pk_query, builder.GetString());
std::vector<std::string> pk;
UNWRAP_STATUS(SqliteQuery::Scan(
conn, pk_query, [](sqlite3_stmt*) { return SQLITE_OK; },
@@ -420,7 +425,8 @@ struct SqliteGetObjectsHelper : public
driver::GetObjectsHelper {
Result<std::optional<Column>> NextColumn() override {
if (!columns) return std::nullopt;
- UNWRAP_RESULT(auto has_next, columns->Next());
+ bool has_next;
+ UNWRAP_RESULT(has_next, columns->Next());
if (!has_next) {
auto query = std::move(*columns);
columns.reset();
@@ -546,7 +552,8 @@ class SqliteDatabase : public
driver::Database<SqliteDatabase> {
if (lifecycle_state_ != driver::LifecycleState::kUninitialized) {
return status::InvalidState("cannot set uri after AdbcDatabaseInit");
}
- UNWRAP_RESULT(auto uri, value.AsString());
+ std::string_view uri;
+ UNWRAP_RESULT(uri, value.AsString());
uri_ = std::move(uri);
return status::Ok();
}
@@ -587,7 +594,8 @@ class SqliteConnection : public
driver::Connection<SqliteConnection> {
SqliteStringBuilder builder;
builder.Append(R"(SELECT * FROM "%w" . "%w")",
catalog.value_or("main").data(),
table_name.data());
- UNWRAP_RESULT(std::string_view query, builder.GetString());
+ std::string_view query;
+ UNWRAP_RESULT(query, builder.GetString());
sqlite3_stmt* stmt = nullptr;
int rc =
@@ -691,7 +699,8 @@ class SqliteConnection : public
driver::Connection<SqliteConnection> {
return status::InvalidState(
"cannot enable extension loading before AdbcConnectionInit");
}
- UNWRAP_RESULT(const bool enabled, value.AsBool());
+ bool enabled;
+ UNWRAP_RESULT(enabled, value.AsBool());
int rc = sqlite3_db_config(conn_, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION,
enabled ? 1 : 0, nullptr);
if (rc != SQLITE_OK) {
@@ -715,7 +724,8 @@ class SqliteConnection : public
driver::Connection<SqliteConnection> {
}
const char* extension_entrypoint = nullptr;
if (value.has_value()) {
- UNWRAP_RESULT(auto entrypoint, value.AsString());
+ std::string_view entrypoint;
+ UNWRAP_RESULT(entrypoint, value.AsString());
extension_entrypoint = entrypoint.data();
}
@@ -814,7 +824,8 @@ class SqliteStatement : public
driver::Statement<SqliteStatement> {
table_builder.Append(R"(main . "%w")", state.target_table->c_str());
}
- UNWRAP_RESULT(std::string_view table, table_builder.GetString());
+ std::string_view table;
+ UNWRAP_RESULT(table, table_builder.GetString());
switch (state.table_exists_) {
case Base::TableExists::kAppend:
@@ -892,9 +903,12 @@ class SqliteStatement : public
driver::Statement<SqliteStatement> {
}
insert_query.Append(")");
- UNWRAP_RESULT(std::string_view create, create_query.GetString());
- UNWRAP_RESULT(std::string_view drop, drop_query.GetString());
- UNWRAP_RESULT(std::string_view insert, insert_query.GetString());
+ std::string_view create;
+ UNWRAP_RESULT(create, create_query.GetString());
+ std::string_view drop;
+ UNWRAP_RESULT(drop, drop_query.GetString());
+ std::string_view insert;
+ UNWRAP_RESULT(insert, insert_query.GetString());
// Drop/create tables as needed
@@ -1139,7 +1153,8 @@ class SqliteStatement : public
driver::Statement<SqliteStatement> {
Status SetOptionImpl(std::string_view key, driver::Option value) {
if (key == kStatementOptionBatchRows) {
- UNWRAP_RESULT(int64_t batch_size, value.AsInt());
+ int64_t batch_size;
+ UNWRAP_RESULT(batch_size, value.AsInt());
if (batch_size >= std::numeric_limits<int>::max() || batch_size <= 0) {
return status::fmt::InvalidArgument(
"{} Invalid statement option value {}={} (value is non-positive or
out of "
diff --git a/c/vendor/nanoarrow/nanoarrow.h b/c/vendor/nanoarrow/nanoarrow.h
index 539b2ac9f..8a2e78cb7 100644
--- a/c/vendor/nanoarrow/nanoarrow.h
+++ b/c/vendor/nanoarrow/nanoarrow.h
@@ -19,9 +19,9 @@
#define NANOARROW_CONFIG_H_INCLUDED
#define NANOARROW_VERSION_MAJOR 0
-#define NANOARROW_VERSION_MINOR 8
+#define NANOARROW_VERSION_MINOR 9
#define NANOARROW_VERSION_PATCH 0
-#define NANOARROW_VERSION "0.8.0"
+#define NANOARROW_VERSION "0.9.0-SNAPSHOT"
#define NANOARROW_VERSION_INT \
(NANOARROW_VERSION_MAJOR * 10000 + NANOARROW_VERSION_MINOR * 100 + \
@@ -181,6 +181,13 @@ struct ArrowArrayStream {
if (NAME) return NAME; \
} while (0)
+// __COUNTER__ is not guaranteed to be available and some compiler warnings
may occur
+// if we use it (-Wc2y-extensions). We don't strictly need it because of the
+// do { ... } while(0) scoping and because we never need the return value to
live
+// outside the temporary scope. Here we define a suffix that is unlikely to
collide
+// with anything in EXPR.
+#define _NANOARROW_UNIQUE_SUFFIX _nanoarrow_unique_suffix
+
#define _NANOARROW_CHECK_RANGE(x_, min_, max_) \
NANOARROW_RETURN_NOT_OK((x_ >= min_ && x_ <= max_) ? NANOARROW_OK : EINVAL)
@@ -305,7 +312,8 @@ static inline void ArrowErrorSetString(struct ArrowError*
error, const char* src
/// \brief Check the result of an expression and return it if not NANOARROW_OK
/// \ingroup nanoarrow-errors
#define NANOARROW_RETURN_NOT_OK(EXPR) \
- _NANOARROW_RETURN_NOT_OK_IMPL(_NANOARROW_MAKE_NAME(errno_status_,
__COUNTER__), EXPR)
+ _NANOARROW_RETURN_NOT_OK_IMPL( \
+ _NANOARROW_MAKE_NAME(errno_status_, _NANOARROW_UNIQUE_SUFFIX), EXPR)
/// \brief Check the result of an expression and return it if not NANOARROW_OK,
/// adding an auto-generated message to an ArrowError.
@@ -314,9 +322,10 @@ static inline void ArrowErrorSetString(struct ArrowError*
error, const char* src
/// This macro is used to ensure that functions that accept an ArrowError
/// as input always set its message when returning an error code (e.g., when
calling
/// a nanoarrow function that does *not* accept ArrowError).
-#define NANOARROW_RETURN_NOT_OK_WITH_ERROR(EXPR, ERROR_EXPR) \
- _NANOARROW_RETURN_NOT_OK_WITH_ERROR_IMPL( \
- _NANOARROW_MAKE_NAME(errno_status_, __COUNTER__), EXPR, ERROR_EXPR,
#EXPR)
+#define NANOARROW_RETURN_NOT_OK_WITH_ERROR(EXPR, ERROR_EXPR)
\
+ _NANOARROW_RETURN_NOT_OK_WITH_ERROR_IMPL(
\
+ _NANOARROW_MAKE_NAME(errno_status_, _NANOARROW_UNIQUE_SUFFIX), EXPR,
ERROR_EXPR, \
+ #EXPR)
#if defined(NANOARROW_DEBUG) && !defined(NANOARROW_PRINT_AND_DIE)
#define NANOARROW_PRINT_AND_DIE(VALUE, EXPR_STR)
\
@@ -343,7 +352,8 @@ static inline void ArrowErrorSetString(struct ArrowError*
error, const char* src
/// be defining the NANOARROW_PRINT_AND_DIE macro before including nanoarrow.h
/// This macro is provided as a convenience for users and is not used
internally.
#define NANOARROW_ASSERT_OK(EXPR) \
- _NANOARROW_ASSERT_OK_IMPL(_NANOARROW_MAKE_NAME(errno_status_, __COUNTER__),
EXPR, #EXPR)
+ _NANOARROW_ASSERT_OK_IMPL( \
+ _NANOARROW_MAKE_NAME(errno_status_, _NANOARROW_UNIQUE_SUFFIX), EXPR,
#EXPR)
#define _NANOARROW_DCHECK_IMPL(EXPR, EXPR_STR) \
do { \
diff --git a/c/vendor/nanoarrow/nanoarrow.hpp b/c/vendor/nanoarrow/nanoarrow.hpp
index 59773b7db..595971b77 100644
--- a/c/vendor/nanoarrow/nanoarrow.hpp
+++ b/c/vendor/nanoarrow/nanoarrow.hpp
@@ -98,9 +98,9 @@ class Exception : public std::exception {
} while (0)
#endif
-#define NANOARROW_THROW_NOT_OK(EXPR)
\
- _NANOARROW_THROW_NOT_OK_IMPL(_NANOARROW_MAKE_NAME(errno_status_,
__COUNTER__), EXPR, \
- #EXPR)
+#define NANOARROW_THROW_NOT_OK(EXPR) \
+ _NANOARROW_THROW_NOT_OK_IMPL( \
+ _NANOARROW_MAKE_NAME(errno_status_, _NANOARROW_UNIQUE_SUFFIX), EXPR,
#EXPR)
/// @}
diff --git a/c/vendor/vendor_nanoarrow.sh b/c/vendor/vendor_nanoarrow.sh
index e2c2b869c..d11899230 100755
--- a/c/vendor/vendor_nanoarrow.sh
+++ b/c/vendor/vendor_nanoarrow.sh
@@ -21,7 +21,7 @@
main() {
local -r repo_url="https://github.com/apache/arrow-nanoarrow";
# Check releases page: https://github.com/apache/arrow-nanoarrow/releases/
- local -r commit_sha=a579fbf5d192e85b6249935e117de7d02a6dc4e9
+ local -r commit_sha=af347fa31d0e2dca6f6b6f818849a437244b6bf5
echo "Fetching $commit_sha from $repo_url"
SCRATCH=$(mktemp -d)
diff --git a/docs/source/cpp/recipe_driver/driver_example.cc
b/docs/source/cpp/recipe_driver/driver_example.cc
index 9c7ae75f8..5b4685ba8 100644
--- a/docs/source/cpp/recipe_driver/driver_example.cc
+++ b/docs/source/cpp/recipe_driver/driver_example.cc
@@ -98,7 +98,7 @@
/// * :cpp:class:`adbc::driver::Result`: The ``Result<T>`` is used as a return
/// value for functions that on success return a value of type ``T`` and on
/// failure communicate their error using a ``Status``. You can use
-/// ``UNWRAP_RESULT(some_type value, some_call())`` as shorthand for
+/// ``UNWRAP_RESULT(value, some_call())`` as shorthand for
///
/// .. code-block:: cpp
///
@@ -138,7 +138,8 @@ class DriverExampleDatabase : public
adbc::driver::Database<DriverExampleDatabas
Status SetOptionImpl(std::string_view key, Option value) override {
// Handle and validate options implemented by this driver
if (key == "uri") {
- UNWRAP_RESULT(std::string_view uri, value.AsString());
+ std::string_view uri;
+ UNWRAP_RESULT(uri, value.AsString());
if (uri.find("file://") != 0) {
return adbc::driver::status::InvalidArgument(
