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 da37a11 fix(c/driver/sqlite): fix nullability of GetInfo schema (#457)
da37a11 is described below
commit da37a1138ae51a9973e3af4d6740ce037069f52b
Author: David Li <[email protected]>
AuthorDate: Tue Feb 14 15:30:20 2023 -0500
fix(c/driver/sqlite): fix nullability of GetInfo schema (#457)
Also updates Nanoarrow.
Fixes #453.
---
c/driver/postgresql/postgresql_test.cc | 2 +-
c/driver/postgresql/statement.cc | 23 ++-
c/driver/sqlite/sqlite.c | 30 ++--
c/driver/sqlite/sqlite_test.cc | 36 ++---
c/driver/sqlite/statement_reader.c | 10 +-
c/validation/adbc_validation.cc | 54 ++++---
c/validation/adbc_validation_util.cc | 7 +-
c/validation/adbc_validation_util.h | 4 +-
c/vendor/nanoarrow/nanoarrow.c | 249 +++++++++++++++++----------------
c/vendor/nanoarrow/nanoarrow.h | 107 +++++++-------
10 files changed, 275 insertions(+), 247 deletions(-)
diff --git a/c/driver/postgresql/postgresql_test.cc
b/c/driver/postgresql/postgresql_test.cc
index 3a41018..ba118f0 100644
--- a/c/driver/postgresql/postgresql_test.cc
+++ b/c/driver/postgresql/postgresql_test.cc
@@ -228,7 +228,7 @@ TEST_P(PostgresTypeTest, SelectValue) {
} else if constexpr (std::is_same_v<T, std::string>) {
ArrowStringView view =
ArrowArrayViewGetStringUnsafe(reader.array_view->children[0], 0);
- ASSERT_EQ(arg.size(), view.n_bytes);
+ ASSERT_EQ(arg.size(), view.size_bytes);
ASSERT_EQ(0, std::strncmp(arg.c_str(), view.data, arg.size()));
} else {
FAIL() << "Unimplemented case";
diff --git a/c/driver/postgresql/statement.cc b/c/driver/postgresql/statement.cc
index 0a13931..968badd 100644
--- a/c/driver/postgresql/statement.cc
+++ b/c/driver/postgresql/statement.cc
@@ -191,7 +191,7 @@ struct BindStream {
ArrowSchemaViewInit(&bind_schema_view, &bind_schema.value, /*error*/
nullptr),
error);
- if (bind_schema_view.data_type != ArrowType::NANOARROW_TYPE_STRUCT) {
+ if (bind_schema_view.type != ArrowType::NANOARROW_TYPE_STRUCT) {
SetError(error, "Bind parameters must have type STRUCT");
return ADBC_STATUS_INVALID_STATE;
}
@@ -215,7 +215,7 @@ struct BindStream {
for (size_t i = 0; i < bind_schema_fields.size(); i++) {
PgType pg_type;
- switch (bind_schema_fields[i].data_type) {
+ switch (bind_schema_fields[i].type) {
case ArrowType::NANOARROW_TYPE_INT16:
pg_type = PgType::kInt2;
param_lengths[i] = 2;
@@ -235,7 +235,7 @@ struct BindStream {
default:
// TODO: data type to string
SetError(error, "Field #", i + 1, " ('",
bind_schema->children[i]->name,
- "') has unsupported parameter type ",
bind_schema_fields[i].data_type);
+ "') has unsupported parameter type ",
bind_schema_fields[i].type);
return ADBC_STATUS_NOT_IMPLEMENTED;
}
@@ -244,7 +244,7 @@ struct BindStream {
// TODO: data type to string
SetError(error, "Field #", i + 1, " ('",
bind_schema->children[i]->name,
"') has type with no corresponding PostgreSQL type ",
- bind_schema_fields[i].data_type);
+ bind_schema_fields[i].type);
return ADBC_STATUS_NOT_IMPLEMENTED;
}
}
@@ -303,7 +303,7 @@ struct BindStream {
} else {
param_values[col] = param_values_buffer.data() +
param_values_offsets[col];
}
- switch (bind_schema_fields[col].data_type) {
+ switch (bind_schema_fields[col].type) {
case ArrowType::NANOARROW_TYPE_INT64: {
const int64_t value = ToNetworkInt64(
array_view->children[col]->buffer_views[1].data.as_int64[row]);
@@ -314,7 +314,7 @@ struct BindStream {
const ArrowBufferView view =
ArrowArrayViewGetBytesUnsafe(array_view->children[col], row);
// TODO: overflow check?
- param_lengths[col] = static_cast<int>(view.n_bytes);
+ param_lengths[col] = static_cast<int>(view.size_bytes);
param_values[col] = const_cast<char*>(view.data.as_char);
break;
}
@@ -322,7 +322,7 @@ struct BindStream {
// TODO: data type to string
SetError(error, "Field #", col + 1, " ('",
bind_schema->children[col]->name,
"') has unsupported type for ingestion ",
- bind_schema_fields[col].data_type);
+ bind_schema_fields[col].type);
return ADBC_STATUS_NOT_IMPLEMENTED;
}
}
@@ -519,7 +519,7 @@ int TupleReader::AppendNext(struct ArrowSchemaView* fields,
const char* buf, int
// TODO: set error message here
CHECK_NA(ArrowBitmapAppend(bitmap, field_length >= 0, 1));
- switch (fields[col].data_type) {
+ switch (fields[col].type) {
case NANOARROW_TYPE_BOOL: {
// DCHECK_EQ(field_length, 1);
struct ArrowBuffer* buffer = ArrowArrayBuffer(out->children[col], 1);
@@ -612,7 +612,7 @@ int TupleReader::AppendNext(struct ArrowSchemaView* fields,
const char* buf, int
default:
last_error_ = StringBuilder("[libpq] Column #", col + 1, " (\"",
schema_.children[col]->name,
- "\") has unsupported type ",
fields[col].data_type);
+ "\") has unsupported type ",
fields[col].type);
return ENOTSUP;
}
}
@@ -712,7 +712,7 @@ AdbcStatusCode PostgresStatement::CreateBulkTable(
for (size_t i = 0; i < source_schema_fields.size(); i++) {
if (i > 0) create += ", ";
create += source_schema.children[i]->name;
- switch (source_schema_fields[i].data_type) {
+ switch (source_schema_fields[i].type) {
case ArrowType::NANOARROW_TYPE_INT16:
create += " SMALLINT";
break;
@@ -728,8 +728,7 @@ AdbcStatusCode PostgresStatement::CreateBulkTable(
default:
// TODO: data type to string
SetError(error, "Field #", i + 1, " ('",
source_schema.children[i]->name,
- "') has unsupported type for ingestion ",
- source_schema_fields[i].data_type);
+ "') has unsupported type for ingestion ",
source_schema_fields[i].type);
return ADBC_STATUS_NOT_IMPLEMENTED;
}
}
diff --git a/c/driver/sqlite/sqlite.c b/c/driver/sqlite/sqlite.c
index b833b96..6f49350 100644
--- a/c/driver/sqlite/sqlite.c
+++ b/c/driver/sqlite/sqlite.c
@@ -333,7 +333,7 @@ AdbcStatusCode SqliteConnectionGetInfoImpl(const uint32_t*
info_codes,
break;
case ADBC_INFO_DRIVER_ARROW_VERSION:
RAISE_ADBC(SqliteConnectionGetInfoAppendStringImpl(array,
info_codes[i],
- NANOARROW_BUILD_ID,
error));
+ NANOARROW_VERSION,
error));
break;
default:
// Ignore
@@ -620,7 +620,7 @@ AdbcStatusCode SqliteConnectionGetColumnsImpl(
while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
const char* col_name = (const char*)sqlite3_column_text(stmt, 1);
struct ArrowStringView str = {.data = col_name,
- .n_bytes = sqlite3_column_bytes(stmt, 1)};
+ .size_bytes = sqlite3_column_bytes(stmt, 1)};
CHECK_NA(INTERNAL, ArrowArrayAppendString(column_name_col, str), error);
const int32_t col_cid = sqlite3_column_int(stmt, 0);
@@ -632,7 +632,7 @@ AdbcStatusCode SqliteConnectionGetColumnsImpl(
const char* col_type = (const char*)sqlite3_column_text(stmt, 2);
if (col_type) {
str.data = col_type;
- str.n_bytes = sqlite3_column_bytes(stmt, 2);
+ str.size_bytes = sqlite3_column_bytes(stmt, 2);
CHECK_NA(INTERNAL, ArrowArrayAppendString(xdbc_type_name_col, str),
error);
} else {
CHECK_NA(INTERNAL, ArrowArrayAppendNull(xdbc_type_name_col, 1), error);
@@ -654,7 +654,7 @@ AdbcStatusCode SqliteConnectionGetColumnsImpl(
const char* col_def = (const char*)sqlite3_column_text(stmt, 4);
if (col_def) {
str.data = col_def;
- str.n_bytes = sqlite3_column_bytes(stmt, 4);
+ str.size_bytes = sqlite3_column_bytes(stmt, 4);
CHECK_NA(INTERNAL, ArrowArrayAppendString(xdbc_column_def_col, str),
error);
} else {
CHECK_NA(INTERNAL, ArrowArrayAppendNull(xdbc_column_def_col, 1), error);
@@ -666,10 +666,10 @@ AdbcStatusCode SqliteConnectionGetColumnsImpl(
if (col_notnull == 0) {
str.data = "YES";
- str.n_bytes = 3;
+ str.size_bytes = 3;
} else {
str.data = "NO";
- str.n_bytes = 2;
+ str.size_bytes = 2;
}
CHECK_NA(INTERNAL, ArrowArrayAppendString(xdbc_is_nullable_col, str),
error);
@@ -727,7 +727,7 @@ AdbcStatusCode SqliteConnectionGetConstraintsImpl(
ArrowArrayAppendString(
constraint_column_names_items,
(struct ArrowStringView){.data = (const
char*)sqlite3_column_text(pk_stmt, 0),
- .n_bytes = sqlite3_column_bytes(pk_stmt,
0)}),
+ .size_bytes =
sqlite3_column_bytes(pk_stmt, 0)}),
error);
}
if (has_primary_key) {
@@ -767,8 +767,8 @@ AdbcStatusCode SqliteConnectionGetConstraintsImpl(
CHECK_NA(INTERNAL,
ArrowArrayAppendString(
constraint_column_names_items,
- (struct ArrowStringView){.data = from_col,
- .n_bytes =
sqlite3_column_bytes(pk_stmt, 3)}),
+ (struct ArrowStringView){
+ .data = from_col, .size_bytes =
sqlite3_column_bytes(pk_stmt, 3)}),
error);
CHECK_NA(INTERNAL, ArrowArrayAppendString(fk_catalog_col,
ArrowCharView("main")),
error);
@@ -776,14 +776,14 @@ AdbcStatusCode SqliteConnectionGetConstraintsImpl(
CHECK_NA(INTERNAL,
ArrowArrayAppendString(
fk_table_col,
- (struct ArrowStringView){.data = to_table,
- .n_bytes =
sqlite3_column_bytes(pk_stmt, 2)}),
+ (struct ArrowStringView){
+ .data = to_table, .size_bytes =
sqlite3_column_bytes(pk_stmt, 2)}),
error);
CHECK_NA(INTERNAL,
ArrowArrayAppendString(
fk_column_name_col,
- (struct ArrowStringView){.data = to_col,
- .n_bytes =
sqlite3_column_bytes(pk_stmt, 4)}),
+ (struct ArrowStringView){
+ .data = to_col, .size_bytes =
sqlite3_column_bytes(pk_stmt, 4)}),
error);
}
}
@@ -825,12 +825,12 @@ AdbcStatusCode SqliteConnectionGetTablesInner(
}
struct ArrowStringView str = {.data = cur_table_type,
- .n_bytes = sqlite3_column_bytes(tables_stmt,
1)};
+ .size_bytes =
sqlite3_column_bytes(tables_stmt, 1)};
CHECK_NA(INTERNAL, ArrowArrayAppendString(table_type_col, str), error);
const char* cur_table = (const char*)sqlite3_column_text(tables_stmt, 0);
str.data = cur_table;
- str.n_bytes = sqlite3_column_bytes(tables_stmt, 0);
+ str.size_bytes = sqlite3_column_bytes(tables_stmt, 0);
CHECK_NA(INTERNAL, ArrowArrayAppendString(table_name_col, str), error);
if (columns_stmt == NULL) {
diff --git a/c/driver/sqlite/sqlite_test.cc b/c/driver/sqlite/sqlite_test.cc
index 418035c..3af4a8b 100644
--- a/c/driver/sqlite/sqlite_test.cc
+++ b/c/driver/sqlite/sqlite_test.cc
@@ -159,7 +159,7 @@ class SqliteReaderTest : public ::testing::Test {
TEST_F(SqliteReaderTest, IntsNulls) {
adbc_validation::StreamReader reader;
ASSERT_NO_FATAL_FAILURE(ExecSelect("(NULL), (1), (NULL), (-1)", kInferRows,
&reader));
- ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(CompareArray<int64_t>(reader.array_view->children[0],
@@ -170,7 +170,7 @@ TEST_F(SqliteReaderTest, FloatsNulls) {
adbc_validation::StreamReader reader;
ASSERT_NO_FATAL_FAILURE(
ExecSelect("(NULL), (1.0), (NULL), (-1.0), (0.0)", kInferRows, &reader));
- ASSERT_EQ(NANOARROW_TYPE_DOUBLE, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_DOUBLE, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(CompareArray<double>(
@@ -181,7 +181,7 @@ TEST_F(SqliteReaderTest, IntsFloatsNulls) {
adbc_validation::StreamReader reader;
ASSERT_NO_FATAL_FAILURE(
ExecSelect("(NULL), (1), (NULL), (-1.0), (0)", kInferRows, &reader));
- ASSERT_EQ(NANOARROW_TYPE_DOUBLE, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_DOUBLE, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(CompareArray<double>(
@@ -192,7 +192,7 @@ TEST_F(SqliteReaderTest, IntsNullsStrsNullsInts) {
adbc_validation::StreamReader reader;
ASSERT_NO_FATAL_FAILURE(ExecSelect(
R"((NULL), (1), (NULL), (-1), ("foo"), (NULL), (""), (24))", kInferRows,
&reader));
- ASSERT_EQ(NANOARROW_TYPE_STRING, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_STRING, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(CompareArray<std::string>(
@@ -205,7 +205,7 @@ TEST_F(SqliteReaderTest, IntExtremes) {
ASSERT_NO_FATAL_FAILURE(
ExecSelect(R"((NULL), (9223372036854775807), (NULL),
(-9223372036854775808))",
kInferRows, &reader));
- ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(
@@ -219,7 +219,7 @@ TEST_F(SqliteReaderTest, IntExtremesStrs) {
ASSERT_NO_FATAL_FAILURE(ExecSelect(
R"((NULL), (9223372036854775807), (-9223372036854775808), (""),
(9223372036854775807), (-9223372036854775808))",
kInferRows, &reader));
- ASSERT_EQ(NANOARROW_TYPE_STRING, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_STRING, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(CompareArray<std::string>(reader.array_view->children[0],
@@ -237,7 +237,7 @@ TEST_F(SqliteReaderTest, FloatExtremes) {
adbc_validation::StreamReader reader;
ASSERT_NO_FATAL_FAILURE(
ExecSelect(R"((NULL), (9e999), (NULL), (-9e999))", kInferRows, &reader));
- ASSERT_EQ(NANOARROW_TYPE_DOUBLE, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_DOUBLE, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(CompareArray<double>(
@@ -253,7 +253,7 @@ TEST_F(SqliteReaderTest, IntsFloatsStrs) {
adbc_validation::StreamReader reader;
ASSERT_NO_FATAL_FAILURE(
ExecSelect(R"((1), (1.0), (""), (9e999), (-9e999))", kInferRows,
&reader));
- ASSERT_EQ(NANOARROW_TYPE_STRING, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_STRING, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(
@@ -265,7 +265,7 @@ TEST_F(SqliteReaderTest, InferIntReadInt) {
adbc_validation::StreamReader reader;
ASSERT_NO_FATAL_FAILURE(
ExecSelect(R"((1), (NULL), (2), (NULL))", /*infer_rows=*/2, &reader));
- ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(
CompareArray<int64_t>(reader.array_view->children[0], {1,
std::nullopt}));
@@ -280,7 +280,7 @@ TEST_F(SqliteReaderTest, InferIntRejectFloat) {
adbc_validation::StreamReader reader;
ASSERT_NO_FATAL_FAILURE(
ExecSelect(R"((1), (NULL), (2E0), (NULL))", /*infer_rows=*/2, &reader));
- ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(
CompareArray<int64_t>(reader.array_view->children[0], {1,
std::nullopt}));
@@ -295,7 +295,7 @@ TEST_F(SqliteReaderTest, InferIntRejectStr) {
adbc_validation::StreamReader reader;
ASSERT_NO_FATAL_FAILURE(
ExecSelect(R"((1), (NULL), (""), (NULL))", /*infer_rows=*/2, &reader));
- ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(
CompareArray<int64_t>(reader.array_view->children[0], {1,
std::nullopt}));
@@ -311,7 +311,7 @@ TEST_F(SqliteReaderTest, InferFloatReadIntFloat) {
adbc_validation::StreamReader reader;
ASSERT_NO_FATAL_FAILURE(
ExecSelect(R"((1E0), (NULL), (2E0), (3), (NULL))", /*infer_rows=*/2,
&reader));
- ASSERT_EQ(NANOARROW_TYPE_DOUBLE, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_DOUBLE, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(
CompareArray<double>(reader.array_view->children[0], {1.0,
std::nullopt}));
@@ -329,7 +329,7 @@ TEST_F(SqliteReaderTest, InferFloatRejectStr) {
adbc_validation::StreamReader reader;
ASSERT_NO_FATAL_FAILURE(ExecSelect(R"((1E0), (NULL), (2E0), (3), (""),
(NULL))",
/*infer_rows=*/2, &reader));
- ASSERT_EQ(NANOARROW_TYPE_DOUBLE, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_DOUBLE, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(
CompareArray<double>(reader.array_view->children[0], {1.0,
std::nullopt}));
@@ -348,7 +348,7 @@ TEST_F(SqliteReaderTest, InferStrReadAll) {
adbc_validation::StreamReader reader;
ASSERT_NO_FATAL_FAILURE(ExecSelect(R"((""), (NULL), (2), (3E0), ("foo"),
(NULL))",
/*infer_rows=*/2, &reader));
- ASSERT_EQ(NANOARROW_TYPE_STRING, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_STRING, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(
CompareArray<std::string>(reader.array_view->children[0], {"",
std::nullopt}));
@@ -378,7 +378,7 @@ TEST_F(SqliteReaderTest, InferOneParam) {
ASSERT_NO_FATAL_FAILURE(Exec("SELECT ?", /*infer_rows=*/2, &reader));
ASSERT_EQ(1, reader.schema->n_children);
- ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(
CompareArray<int64_t>(reader.array_view->children[0], {std::nullopt,
2}));
@@ -411,7 +411,7 @@ TEST_F(SqliteReaderTest, InferOneParamStream) {
ASSERT_NO_FATAL_FAILURE(Exec("SELECT ?", /*infer_rows=*/3, &reader));
ASSERT_EQ(1, reader.schema->n_children);
- ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(
CompareArray<int64_t>(reader.array_view->children[0], {std::nullopt, 1,
2}));
@@ -441,7 +441,7 @@ TEST_F(SqliteReaderTest, InferTypedParams) {
ASSERT_NO_FATAL_FAILURE(
Exec("SELECT value FROM foo WHERE idx = ?", /*infer_rows=*/2, &reader));
ASSERT_EQ(1, reader.schema->n_children);
- ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].data_type);
+ ASSERT_EQ(NANOARROW_TYPE_INT64, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(
@@ -472,7 +472,7 @@ class SqliteNumericParamTest : public SqliteReaderTest,
ASSERT_NO_FATAL_FAILURE(Exec("SELECT ?", /*infer_rows=*/2, &reader));
ASSERT_EQ(1, reader.schema->n_children);
- ASSERT_EQ(expected_type, reader.fields[0].data_type);
+ ASSERT_EQ(expected_type, reader.fields[0].type);
ASSERT_NO_FATAL_FAILURE(reader.Next());
ASSERT_NO_FATAL_FAILURE(
CompareArray<CType>(reader.array_view->children[0], {std::nullopt,
0}));
diff --git a/c/driver/sqlite/statement_reader.c
b/c/driver/sqlite/statement_reader.c
index e91491b..694b8cc 100644
--- a/c/driver/sqlite/statement_reader.c
+++ b/c/driver/sqlite/statement_reader.c
@@ -63,11 +63,11 @@ AdbcStatusCode AdbcSqliteBinderSet(struct AdbcSqliteBinder*
binder,
return ADBC_STATUS_INVALID_ARGUMENT;
}
- if (view.data_type == NANOARROW_TYPE_UNINITIALIZED) {
+ if (view.type == NANOARROW_TYPE_UNINITIALIZED) {
SetError(error, "Column %d has UNINITIALIZED type", i);
return ADBC_STATUS_INTERNAL;
}
- binder->types[i] = view.data_type;
+ binder->types[i] = view.type;
}
return ADBC_STATUS_OK;
@@ -151,7 +151,7 @@ AdbcStatusCode AdbcSqliteBinderBindNext(struct
AdbcSqliteBinder* binder, sqlite3
case NANOARROW_TYPE_LARGE_BINARY: {
struct ArrowBufferView value =
ArrowArrayViewGetBytesUnsafe(binder->batch.children[col],
binder->next_row);
- status = sqlite3_bind_text(stmt, col + 1, value.data.as_char,
value.n_bytes,
+ status = sqlite3_bind_text(stmt, col + 1, value.data.as_char,
value.size_bytes,
SQLITE_STATIC);
break;
}
@@ -191,7 +191,7 @@ AdbcStatusCode AdbcSqliteBinderBindNext(struct
AdbcSqliteBinder* binder, sqlite3
case NANOARROW_TYPE_LARGE_STRING: {
struct ArrowBufferView value =
ArrowArrayViewGetBytesUnsafe(binder->batch.children[col],
binder->next_row);
- status = sqlite3_bind_text(stmt, col + 1, value.data.as_char,
value.n_bytes,
+ status = sqlite3_bind_text(stmt, col + 1, value.data.as_char,
value.size_bytes,
SQLITE_STATIC);
break;
}
@@ -334,7 +334,7 @@ int StatementReaderGetOneValue(struct StatementReader*
reader, int col,
// Let SQLite convert
struct ArrowStringView value = {
.data = (const char*)sqlite3_column_text(reader->stmt, col),
- .n_bytes = sqlite3_column_bytes(reader->stmt, col),
+ .size_bytes = sqlite3_column_bytes(reader->stmt, col),
};
return ArrowArrayAppendString(out, value);
}
diff --git a/c/validation/adbc_validation.cc b/c/validation/adbc_validation.cc
index cd6cd1e..c99f5cc 100644
--- a/c/validation/adbc_validation.cc
+++ b/c/validation/adbc_validation.cc
@@ -272,6 +272,25 @@ void ConnectionTest::TestMetadataGetInfo() {
{"string_list", NANOARROW_TYPE_LIST, NULLABLE},
{"int32_to_int32_list_map", NANOARROW_TYPE_MAP,
NULLABLE},
}));
+
ASSERT_NO_FATAL_FAILURE(CompareSchema(reader.schema->children[1]->children[4],
+ {
+ {"item", NANOARROW_TYPE_STRING,
NULLABLE},
+ }));
+
ASSERT_NO_FATAL_FAILURE(CompareSchema(reader.schema->children[1]->children[5],
+ {
+ {"entries", NANOARROW_TYPE_STRUCT,
NOT_NULL},
+ }));
+ ASSERT_NO_FATAL_FAILURE(
+ CompareSchema(reader.schema->children[1]->children[5]->children[0],
+ {
+ {"key", NANOARROW_TYPE_INT32, NOT_NULL},
+ {"value", NANOARROW_TYPE_LIST, NULLABLE},
+ }));
+ ASSERT_NO_FATAL_FAILURE(
+
CompareSchema(reader.schema->children[1]->children[5]->children[0]->children[1],
+ {
+ {"item", NANOARROW_TYPE_INT32, NULLABLE},
+ }));
std::vector<uint32_t> seen;
while (true) {
@@ -586,7 +605,8 @@ void ConnectionTest::TestMetadataGetObjectsTables() {
tables_index++) {
ArrowStringView table_name = ArrowArrayViewGetStringUnsafe(
db_schema_tables->children[0], tables_index);
- if (std::string_view(table_name.data, table_name.n_bytes) ==
"bulk_ingest") {
+ if (std::string_view(table_name.data, table_name.size_bytes) ==
+ "bulk_ingest") {
found_expected_table = true;
}
@@ -659,7 +679,8 @@ void ConnectionTest::TestMetadataGetObjectsTablesTypes() {
tables_index++) {
ArrowStringView table_name = ArrowArrayViewGetStringUnsafe(
db_schema_tables->children[0], tables_index);
- if (std::string_view(table_name.data, table_name.n_bytes) ==
"bulk_ingest") {
+ if (std::string_view(table_name.data, table_name.size_bytes) ==
+ "bulk_ingest") {
found_expected_table = true;
}
@@ -762,7 +783,8 @@ void ConnectionTest::TestMetadataGetObjectsColumns() {
ASSERT_FALSE(ArrowArrayViewIsNull(table_constraints_list,
tables_index))
<< "Row " << row << " should have non-null table_constraints";
- if (std::string_view(table_name.data, table_name.n_bytes) ==
"bulk_ingest") {
+ if (std::string_view(table_name.data, table_name.size_bytes) ==
+ "bulk_ingest") {
found_expected_table = true;
for (int64_t columns_index =
@@ -772,7 +794,7 @@ void ConnectionTest::TestMetadataGetObjectsColumns() {
columns_index++) {
ArrowStringView name = ArrowArrayViewGetStringUnsafe(
table_columns->children[0], columns_index);
- column_names.push_back(std::string(name.data, name.n_bytes));
+ column_names.push_back(std::string(name.data,
name.size_bytes));
ordinal_positions.push_back(
static_cast<int32_t>(ArrowArrayViewGetIntUnsafe(
table_columns->children[1], columns_index)));
@@ -1171,7 +1193,7 @@ void StatementTest::TestSqlPartitionedInts() {
ASSERT_EQ(1, reader.array->length);
ASSERT_EQ(1, reader.array->n_children);
- switch (reader.fields[0].data_type) {
+ switch (reader.fields[0].type) {
case NANOARROW_TYPE_INT32:
ASSERT_NO_FATAL_FAILURE(
CompareArray<int32_t>(reader.array_view->children[0], {42}));
@@ -1181,7 +1203,7 @@ void StatementTest::TestSqlPartitionedInts() {
CompareArray<int64_t>(reader.array_view->children[0], {42}));
break;
default:
- FAIL() << "Unexpected data type: " << reader.fields[0].data_type;
+ FAIL() << "Unexpected data type: " << reader.fields[0].type;
}
ASSERT_NO_FATAL_FAILURE(reader.Next());
@@ -1235,7 +1257,7 @@ void StatementTest::TestSqlPrepareSelectNoParams() {
ASSERT_EQ(1, reader.array->length);
ASSERT_EQ(1, reader.array->n_children);
- switch (reader.fields[0].data_type) {
+ switch (reader.fields[0].type) {
case NANOARROW_TYPE_INT32:
ASSERT_NO_FATAL_FAILURE(CompareArray<int32_t>(reader.array_view->children[0],
{1}));
break;
@@ -1243,7 +1265,7 @@ void StatementTest::TestSqlPrepareSelectNoParams() {
ASSERT_NO_FATAL_FAILURE(CompareArray<int64_t>(reader.array_view->children[0],
{1}));
break;
default:
- FAIL() << "Unexpected data type: " << reader.fields[0].data_type;
+ FAIL() << "Unexpected data type: " << reader.fields[0].type;
}
ASSERT_NO_FATAL_FAILURE(reader.Next());
@@ -1300,7 +1322,7 @@ void StatementTest::TestSqlPrepareSelectParams() {
auto start = nrows;
auto end = nrows + reader.array->length;
- switch (reader.fields[0].data_type) {
+ switch (reader.fields[0].type) {
case NANOARROW_TYPE_INT32:
ASSERT_NO_FATAL_FAILURE(CompareArray<int32_t>(
reader.array_view->children[0],
@@ -1312,7 +1334,7 @@ void StatementTest::TestSqlPrepareSelectParams() {
{expected_int64.begin() + start, expected_int64.begin() + end}));
break;
default:
- FAIL() << "Unexpected data type: " << reader.fields[0].data_type;
+ FAIL() << "Unexpected data type: " << reader.fields[0].type;
}
ASSERT_NO_FATAL_FAILURE(CompareArray<std::string>(
reader.array_view->children[1],
@@ -1559,7 +1581,7 @@ void StatementTest::TestSqlQueryInts() {
ASSERT_EQ(1, reader.array->length);
ASSERT_EQ(1, reader.array->n_children);
- switch (reader.fields[0].data_type) {
+ switch (reader.fields[0].type) {
case NANOARROW_TYPE_INT32:
ASSERT_NO_FATAL_FAILURE(
CompareArray<int32_t>(reader.array_view->children[0], {42}));
@@ -1569,7 +1591,7 @@ void StatementTest::TestSqlQueryInts() {
CompareArray<int64_t>(reader.array_view->children[0], {42}));
break;
default:
- FAIL() << "Unexpected data type: " << reader.fields[0].data_type;
+ FAIL() << "Unexpected data type: " << reader.fields[0].type;
}
ASSERT_NO_FATAL_FAILURE(reader.Next());
@@ -1602,7 +1624,7 @@ void StatementTest::TestSqlQueryFloats() {
ASSERT_FALSE(ArrowArrayViewIsNull(&reader.array_view.value, 0));
ASSERT_FALSE(ArrowArrayViewIsNull(reader.array_view->children[0], 0));
- switch (reader.fields[0].data_type) {
+ switch (reader.fields[0].type) {
case NANOARROW_TYPE_FLOAT:
ASSERT_NO_FATAL_FAILURE(
CompareArray<float>(reader.array_view->children[0], {1.0f}));
@@ -1612,7 +1634,7 @@ void StatementTest::TestSqlQueryFloats() {
CompareArray<double>(reader.array_view->children[0], {1.0}));
break;
default:
- FAIL() << "Unexpected data type: " << reader.fields[0].data_type;
+ FAIL() << "Unexpected data type: " << reader.fields[0].type;
}
ASSERT_NO_FATAL_FAILURE(reader.Next());
@@ -1645,14 +1667,14 @@ void StatementTest::TestSqlQueryStrings() {
ASSERT_FALSE(ArrowArrayViewIsNull(&reader.array_view.value, 0));
ASSERT_FALSE(ArrowArrayViewIsNull(reader.array_view->children[0], 0));
- switch (reader.fields[0].data_type) {
+ switch (reader.fields[0].type) {
case NANOARROW_TYPE_STRING: {
ASSERT_NO_FATAL_FAILURE(
CompareArray<std::string>(reader.array_view->children[0],
{"SaShiSuSeSo"}));
break;
}
default:
- FAIL() << "Unexpected data type: " << reader.fields[0].data_type;
+ FAIL() << "Unexpected data type: " << reader.fields[0].type;
}
ASSERT_NO_FATAL_FAILURE(reader.Next());
diff --git a/c/validation/adbc_validation_util.cc
b/c/validation/adbc_validation_util.cc
index 67e5dce..e67be6d 100644
--- a/c/validation/adbc_validation_util.cc
+++ b/c/validation/adbc_validation_util.cc
@@ -236,8 +236,9 @@ void CompareSchema(
struct ArrowSchemaView view;
ASSERT_THAT(ArrowSchemaViewInit(&view, schema, &na_error),
IsOkErrno(&na_error));
- ASSERT_THAT(view.data_type, ::testing::AnyOf(NANOARROW_TYPE_LIST,
NANOARROW_TYPE_STRUCT,
- NANOARROW_TYPE_DENSE_UNION));
+ ASSERT_THAT(view.type,
+ ::testing::AnyOf(NANOARROW_TYPE_LIST, NANOARROW_TYPE_MAP,
+ NANOARROW_TYPE_STRUCT,
NANOARROW_TYPE_DENSE_UNION));
ASSERT_EQ(fields.size(), schema->n_children);
for (int64_t i = 0; i < schema->n_children; i++) {
@@ -245,7 +246,7 @@ void CompareSchema(
struct ArrowSchemaView field_view;
ASSERT_THAT(ArrowSchemaViewInit(&field_view, schema->children[i],
&na_error),
IsOkErrno(&na_error));
- ASSERT_EQ(std::get<1>(fields[i]), field_view.data_type);
+ ASSERT_EQ(std::get<1>(fields[i]), field_view.type);
ASSERT_EQ(std::get<2>(fields[i]),
(schema->children[i]->flags & ARROW_FLAG_NULLABLE) != 0)
<< "Nullability mismatch";
diff --git a/c/validation/adbc_validation_util.h
b/c/validation/adbc_validation_util.h
index ca9d9da..9c23ab3 100644
--- a/c/validation/adbc_validation_util.h
+++ b/c/validation/adbc_validation_util.h
@@ -235,7 +235,7 @@ int MakeArray(struct ArrowArray* parent, struct ArrowArray*
array,
} else if constexpr (std::is_same<T, std::string>::value) {
struct ArrowStringView view;
view.data = v->c_str();
- view.n_bytes = v->size();
+ view.size_bytes = v->size();
if (int errno_res = ArrowArrayAppendString(array, view); errno_res !=
0) {
return errno_res;
}
@@ -327,7 +327,7 @@ void CompareArray(struct ArrowArrayView* array,
ASSERT_EQ(*v, array->buffer_views[1].data.as_int64[i]);
} else if constexpr (std::is_same<T, std::string>::value) {
struct ArrowStringView view = ArrowArrayViewGetStringUnsafe(array, i);
- std::string str(view.data, view.n_bytes);
+ std::string str(view.data, view.size_bytes);
ASSERT_EQ(*v, str);
} else {
static_assert(!sizeof(T), "Not yet implemented");
diff --git a/c/vendor/nanoarrow/nanoarrow.c b/c/vendor/nanoarrow/nanoarrow.c
index 7f9d18c..23042dc 100644
--- a/c/vendor/nanoarrow/nanoarrow.c
+++ b/c/vendor/nanoarrow/nanoarrow.c
@@ -24,8 +24,6 @@
#include "nanoarrow.h"
-const char* ArrowNanoarrowBuildId(void) { return NANOARROW_BUILD_ID; }
-
const char* ArrowNanoarrowVersion() { return NANOARROW_VERSION; }
int ArrowNanoarrowVersionInt() { return NANOARROW_VERSION_INT; }
@@ -267,8 +265,8 @@ static void ArrowSchemaRelease(struct ArrowSchema* schema) {
schema->release = NULL;
}
-static const char* ArrowSchemaFormatTemplate(enum ArrowType data_type) {
- switch (data_type) {
+static const char* ArrowSchemaFormatTemplate(enum ArrowType type) {
+ switch (type) {
case NANOARROW_TYPE_UNINITIALIZED:
return NULL;
case NANOARROW_TYPE_NA:
@@ -335,8 +333,8 @@ static const char* ArrowSchemaFormatTemplate(enum ArrowType
data_type) {
}
static int ArrowSchemaInitChildrenIfNeeded(struct ArrowSchema* schema,
- enum ArrowType data_type) {
- switch (data_type) {
+ enum ArrowType type) {
+ switch (type) {
case NANOARROW_TYPE_LIST:
case NANOARROW_TYPE_LARGE_LIST:
case NANOARROW_TYPE_FIXED_SIZE_LIST:
@@ -349,11 +347,13 @@ static int ArrowSchemaInitChildrenIfNeeded(struct
ArrowSchema* schema,
NANOARROW_RETURN_NOT_OK(
ArrowSchemaInitFromType(schema->children[0], NANOARROW_TYPE_STRUCT));
NANOARROW_RETURN_NOT_OK(ArrowSchemaSetName(schema->children[0],
"entries"));
+ schema->children[0]->flags &= ~ARROW_FLAG_NULLABLE;
NANOARROW_RETURN_NOT_OK(ArrowSchemaAllocateChildren(schema->children[0],
2));
ArrowSchemaInit(schema->children[0]->children[0]);
ArrowSchemaInit(schema->children[0]->children[1]);
NANOARROW_RETURN_NOT_OK(
ArrowSchemaSetName(schema->children[0]->children[0], "key"));
+ schema->children[0]->children[0]->flags &= ~ARROW_FLAG_NULLABLE;
NANOARROW_RETURN_NOT_OK(
ArrowSchemaSetName(schema->children[0]->children[1], "value"));
break;
@@ -376,22 +376,22 @@ void ArrowSchemaInit(struct ArrowSchema* schema) {
schema->release = &ArrowSchemaRelease;
}
-ArrowErrorCode ArrowSchemaSetType(struct ArrowSchema* schema, enum ArrowType
data_type) {
+ArrowErrorCode ArrowSchemaSetType(struct ArrowSchema* schema, enum ArrowType
type) {
// We don't allocate the dictionary because it has to be nullptr
// for non-dictionary-encoded arrays.
- // Set the format to a valid format string for data_type
- const char* template_format = ArrowSchemaFormatTemplate(data_type);
+ // Set the format to a valid format string for type
+ const char* template_format = ArrowSchemaFormatTemplate(type);
- // If data_type isn't recognized and not explicitly unset
- if (template_format == NULL && data_type != NANOARROW_TYPE_UNINITIALIZED) {
+ // If type isn't recognized and not explicitly unset
+ if (template_format == NULL && type != NANOARROW_TYPE_UNINITIALIZED) {
return EINVAL;
}
NANOARROW_RETURN_NOT_OK(ArrowSchemaSetFormat(schema, template_format));
// For types with an umabiguous child structure, allocate children
- return ArrowSchemaInitChildrenIfNeeded(schema, data_type);
+ return ArrowSchemaInitChildrenIfNeeded(schema, type);
}
ArrowErrorCode ArrowSchemaSetTypeStruct(struct ArrowSchema* schema, int64_t
n_children) {
@@ -404,11 +404,10 @@ ArrowErrorCode ArrowSchemaSetTypeStruct(struct
ArrowSchema* schema, int64_t n_ch
return NANOARROW_OK;
}
-ArrowErrorCode ArrowSchemaInitFromType(struct ArrowSchema* schema,
- enum ArrowType data_type) {
+ArrowErrorCode ArrowSchemaInitFromType(struct ArrowSchema* schema, enum
ArrowType type) {
ArrowSchemaInit(schema);
- int result = ArrowSchemaSetType(schema, data_type);
+ int result = ArrowSchemaSetType(schema, type);
if (result != NANOARROW_OK) {
schema->release(schema);
return result;
@@ -418,14 +417,14 @@ ArrowErrorCode ArrowSchemaInitFromType(struct
ArrowSchema* schema,
}
ArrowErrorCode ArrowSchemaSetTypeFixedSize(struct ArrowSchema* schema,
- enum ArrowType data_type, int32_t
fixed_size) {
+ enum ArrowType type, int32_t
fixed_size) {
if (fixed_size <= 0) {
return EINVAL;
}
char buffer[64];
int n_chars;
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_FIXED_SIZE_BINARY:
n_chars = snprintf(buffer, sizeof(buffer), "w:%d", (int)fixed_size);
break;
@@ -439,15 +438,14 @@ ArrowErrorCode ArrowSchemaSetTypeFixedSize(struct
ArrowSchema* schema,
buffer[n_chars] = '\0';
NANOARROW_RETURN_NOT_OK(ArrowSchemaSetFormat(schema, buffer));
- if (data_type == NANOARROW_TYPE_FIXED_SIZE_LIST) {
- NANOARROW_RETURN_NOT_OK(ArrowSchemaInitChildrenIfNeeded(schema,
data_type));
+ if (type == NANOARROW_TYPE_FIXED_SIZE_LIST) {
+ NANOARROW_RETURN_NOT_OK(ArrowSchemaInitChildrenIfNeeded(schema, type));
}
return NANOARROW_OK;
}
-ArrowErrorCode ArrowSchemaSetTypeDecimal(struct ArrowSchema* schema,
- enum ArrowType data_type,
+ArrowErrorCode ArrowSchemaSetTypeDecimal(struct ArrowSchema* schema, enum
ArrowType type,
int32_t decimal_precision,
int32_t decimal_scale) {
if (decimal_precision <= 0) {
@@ -456,7 +454,7 @@ ArrowErrorCode ArrowSchemaSetTypeDecimal(struct
ArrowSchema* schema,
char buffer[64];
int n_chars;
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_DECIMAL128:
n_chars =
snprintf(buffer, sizeof(buffer), "d:%d,%d", decimal_precision,
decimal_scale);
@@ -488,8 +486,7 @@ static const char* ArrowTimeUnitFormatString(enum
ArrowTimeUnit time_unit) {
}
}
-ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema,
- enum ArrowType data_type,
+ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema, enum
ArrowType type,
enum ArrowTimeUnit time_unit,
const char* timezone) {
const char* time_unit_str = ArrowTimeUnitFormatString(time_unit);
@@ -499,7 +496,7 @@ ArrowErrorCode ArrowSchemaSetTypeDateTime(struct
ArrowSchema* schema,
char buffer[128];
int n_chars;
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_TIME32:
case NANOARROW_TYPE_TIME64:
if (timezone != NULL) {
@@ -532,8 +529,8 @@ ArrowErrorCode ArrowSchemaSetTypeDateTime(struct
ArrowSchema* schema,
return ArrowSchemaSetFormat(schema, buffer);
}
-ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema,
- enum ArrowType data_type, int64_t
n_children) {
+ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema, enum
ArrowType type,
+ int64_t n_children) {
if (n_children < 0 || n_children > 127) {
return EINVAL;
}
@@ -545,7 +542,7 @@ ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema*
schema,
int n_chars;
char* format_cursor = format_out;
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_SPARSE_UNION:
n_chars = snprintf(format_cursor, format_out_size, "+us:");
format_cursor += n_chars;
@@ -744,9 +741,9 @@ ArrowErrorCode ArrowSchemaDeepCopy(struct ArrowSchema*
schema,
}
static void ArrowSchemaViewSetPrimitive(struct ArrowSchemaView* schema_view,
- enum ArrowType data_type) {
- schema_view->data_type = data_type;
- schema_view->storage_data_type = data_type;
+ enum ArrowType type) {
+ schema_view->type = type;
+ schema_view->storage_type = type;
}
static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
@@ -761,8 +758,8 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
switch (format[0]) {
case 'n':
- schema_view->data_type = NANOARROW_TYPE_NA;
- schema_view->storage_data_type = NANOARROW_TYPE_NA;
+ schema_view->type = NANOARROW_TYPE_NA;
+ schema_view->storage_type = NANOARROW_TYPE_NA;
*format_end_out = format + 1;
return NANOARROW_OK;
case 'b':
@@ -862,8 +859,8 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
// validity + data
case 'w':
- schema_view->data_type = NANOARROW_TYPE_FIXED_SIZE_BINARY;
- schema_view->storage_data_type = NANOARROW_TYPE_FIXED_SIZE_BINARY;
+ schema_view->type = NANOARROW_TYPE_FIXED_SIZE_BINARY;
+ schema_view->storage_type = NANOARROW_TYPE_FIXED_SIZE_BINARY;
if (format[1] != ':' || format[2] == '\0') {
ArrowErrorSet(error, "Expected ':<width>' following 'w'");
return EINVAL;
@@ -874,25 +871,25 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
// validity + offset + data
case 'z':
- schema_view->data_type = NANOARROW_TYPE_BINARY;
- schema_view->storage_data_type = NANOARROW_TYPE_BINARY;
+ schema_view->type = NANOARROW_TYPE_BINARY;
+ schema_view->storage_type = NANOARROW_TYPE_BINARY;
*format_end_out = format + 1;
return NANOARROW_OK;
case 'u':
- schema_view->data_type = NANOARROW_TYPE_STRING;
- schema_view->storage_data_type = NANOARROW_TYPE_STRING;
+ schema_view->type = NANOARROW_TYPE_STRING;
+ schema_view->storage_type = NANOARROW_TYPE_STRING;
*format_end_out = format + 1;
return NANOARROW_OK;
// validity + large_offset + data
case 'Z':
- schema_view->data_type = NANOARROW_TYPE_LARGE_BINARY;
- schema_view->storage_data_type = NANOARROW_TYPE_LARGE_BINARY;
+ schema_view->type = NANOARROW_TYPE_LARGE_BINARY;
+ schema_view->storage_type = NANOARROW_TYPE_LARGE_BINARY;
*format_end_out = format + 1;
return NANOARROW_OK;
case 'U':
- schema_view->data_type = NANOARROW_TYPE_LARGE_STRING;
- schema_view->storage_data_type = NANOARROW_TYPE_LARGE_STRING;
+ schema_view->type = NANOARROW_TYPE_LARGE_STRING;
+ schema_view->storage_type = NANOARROW_TYPE_LARGE_STRING;
*format_end_out = format + 1;
return NANOARROW_OK;
@@ -901,15 +898,15 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
switch (format[1]) {
// list has validity + offset or offset
case 'l':
- schema_view->storage_data_type = NANOARROW_TYPE_LIST;
- schema_view->data_type = NANOARROW_TYPE_LIST;
+ schema_view->storage_type = NANOARROW_TYPE_LIST;
+ schema_view->type = NANOARROW_TYPE_LIST;
*format_end_out = format + 2;
return NANOARROW_OK;
// large list has validity + large_offset or large_offset
case 'L':
- schema_view->storage_data_type = NANOARROW_TYPE_LARGE_LIST;
- schema_view->data_type = NANOARROW_TYPE_LARGE_LIST;
+ schema_view->storage_type = NANOARROW_TYPE_LARGE_LIST;
+ schema_view->type = NANOARROW_TYPE_LARGE_LIST;
*format_end_out = format + 2;
return NANOARROW_OK;
@@ -920,19 +917,19 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
return EINVAL;
}
- schema_view->storage_data_type = NANOARROW_TYPE_FIXED_SIZE_LIST;
- schema_view->data_type = NANOARROW_TYPE_FIXED_SIZE_LIST;
+ schema_view->storage_type = NANOARROW_TYPE_FIXED_SIZE_LIST;
+ schema_view->type = NANOARROW_TYPE_FIXED_SIZE_LIST;
schema_view->fixed_size =
(int32_t)strtol(format + 3, (char**)format_end_out, 10);
return NANOARROW_OK;
case 's':
- schema_view->storage_data_type = NANOARROW_TYPE_STRUCT;
- schema_view->data_type = NANOARROW_TYPE_STRUCT;
+ schema_view->storage_type = NANOARROW_TYPE_STRUCT;
+ schema_view->type = NANOARROW_TYPE_STRUCT;
*format_end_out = format + 2;
return NANOARROW_OK;
case 'm':
- schema_view->storage_data_type = NANOARROW_TYPE_MAP;
- schema_view->data_type = NANOARROW_TYPE_MAP;
+ schema_view->storage_type = NANOARROW_TYPE_MAP;
+ schema_view->type = NANOARROW_TYPE_MAP;
*format_end_out = format + 2;
return NANOARROW_OK;
@@ -940,12 +937,12 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
case 'u':
switch (format[2]) {
case 'd':
- schema_view->storage_data_type = NANOARROW_TYPE_DENSE_UNION;
- schema_view->data_type = NANOARROW_TYPE_DENSE_UNION;
+ schema_view->storage_type = NANOARROW_TYPE_DENSE_UNION;
+ schema_view->type = NANOARROW_TYPE_DENSE_UNION;
break;
case 's':
- schema_view->storage_data_type = NANOARROW_TYPE_SPARSE_UNION;
- schema_view->data_type = NANOARROW_TYPE_SPARSE_UNION;
+ schema_view->storage_type = NANOARROW_TYPE_SPARSE_UNION;
+ schema_view->type = NANOARROW_TYPE_SPARSE_UNION;
break;
default:
ArrowErrorSet(error,
@@ -991,12 +988,12 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
switch (format[2]) {
case 'D':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_DATE32;
+ schema_view->type = NANOARROW_TYPE_DATE32;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'm':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_DATE64;
+ schema_view->type = NANOARROW_TYPE_DATE64;
*format_end_out = format + 3;
return NANOARROW_OK;
default:
@@ -1010,25 +1007,25 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
switch (format[2]) {
case 's':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_TIME32;
+ schema_view->type = NANOARROW_TYPE_TIME32;
schema_view->time_unit = NANOARROW_TIME_UNIT_SECOND;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'm':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_TIME32;
+ schema_view->type = NANOARROW_TYPE_TIME32;
schema_view->time_unit = NANOARROW_TIME_UNIT_MILLI;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'u':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_TIME64;
+ schema_view->type = NANOARROW_TYPE_TIME64;
schema_view->time_unit = NANOARROW_TIME_UNIT_MICRO;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'n':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_TIME64;
+ schema_view->type = NANOARROW_TYPE_TIME64;
schema_view->time_unit = NANOARROW_TIME_UNIT_NANO;
*format_end_out = format + 3;
return NANOARROW_OK;
@@ -1044,22 +1041,22 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
switch (format[2]) {
case 's':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_TIMESTAMP;
+ schema_view->type = NANOARROW_TYPE_TIMESTAMP;
schema_view->time_unit = NANOARROW_TIME_UNIT_SECOND;
break;
case 'm':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_TIMESTAMP;
+ schema_view->type = NANOARROW_TYPE_TIMESTAMP;
schema_view->time_unit = NANOARROW_TIME_UNIT_MILLI;
break;
case 'u':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_TIMESTAMP;
+ schema_view->type = NANOARROW_TYPE_TIMESTAMP;
schema_view->time_unit = NANOARROW_TIME_UNIT_MICRO;
break;
case 'n':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_TIMESTAMP;
+ schema_view->type = NANOARROW_TYPE_TIMESTAMP;
schema_view->time_unit = NANOARROW_TIME_UNIT_NANO;
break;
default:
@@ -1075,8 +1072,7 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
return EINVAL;
}
- schema_view->timezone.data = format + 4;
- schema_view->timezone.n_bytes = strlen(format + 4);
+ schema_view->timezone = format + 4;
*format_end_out = format + strlen(format);
return NANOARROW_OK;
@@ -1085,25 +1081,25 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
switch (format[2]) {
case 's':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_DURATION;
+ schema_view->type = NANOARROW_TYPE_DURATION;
schema_view->time_unit = NANOARROW_TIME_UNIT_SECOND;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'm':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_DURATION;
+ schema_view->type = NANOARROW_TYPE_DURATION;
schema_view->time_unit = NANOARROW_TIME_UNIT_MILLI;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'u':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_DURATION;
+ schema_view->type = NANOARROW_TYPE_DURATION;
schema_view->time_unit = NANOARROW_TIME_UNIT_MICRO;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'n':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_DURATION;
+ schema_view->type = NANOARROW_TYPE_DURATION;
schema_view->time_unit = NANOARROW_TIME_UNIT_NANO;
*format_end_out = format + 3;
return NANOARROW_OK;
@@ -1199,13 +1195,24 @@ static ArrowErrorCode ArrowSchemaViewValidateMap(struct
ArrowSchemaView* schema_
return EINVAL;
}
+ if (schema_view->schema->children[0]->flags & ARROW_FLAG_NULLABLE) {
+ ArrowErrorSet(error,
+ "Expected child of map type to be non-nullable but was
nullable");
+ return EINVAL;
+ }
+
+ if (schema_view->schema->children[0]->children[0]->flags &
ARROW_FLAG_NULLABLE) {
+ ArrowErrorSet(error, "Expected key of map type to be non-nullable but was
nullable");
+ return EINVAL;
+ }
+
return NANOARROW_OK;
}
static ArrowErrorCode ArrowSchemaViewValidateDictionary(
struct ArrowSchemaView* schema_view, struct ArrowError* error) {
// check for valid index type
- switch (schema_view->storage_data_type) {
+ switch (schema_view->storage_type) {
case NANOARROW_TYPE_UINT8:
case NANOARROW_TYPE_INT8:
case NANOARROW_TYPE_UINT16:
@@ -1229,9 +1236,9 @@ static ArrowErrorCode ArrowSchemaViewValidateDictionary(
}
static ArrowErrorCode ArrowSchemaViewValidate(struct ArrowSchemaView*
schema_view,
- enum ArrowType data_type,
+ enum ArrowType type,
struct ArrowError* error) {
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_NA:
case NANOARROW_TYPE_BOOL:
case NANOARROW_TYPE_UINT8:
@@ -1290,7 +1297,7 @@ static ArrowErrorCode ArrowSchemaViewValidate(struct
ArrowSchemaView* schema_vie
default:
ArrowErrorSet(error, "Expected a valid enum ArrowType value but found
%d",
- (int)schema_view->data_type);
+ (int)schema_view->type);
return EINVAL;
}
@@ -1335,7 +1342,7 @@ ArrowErrorCode ArrowSchemaViewInit(struct
ArrowSchemaView* schema_view,
memcpy(child_error, ArrowErrorMessage(error), 1024);
ArrowErrorSet(error, "Error parsing schema->format: %s", child_error);
}
-
+
return result;
}
@@ -1346,25 +1353,25 @@ ArrowErrorCode ArrowSchemaViewInit(struct
ArrowSchemaView* schema_view,
}
if (schema->dictionary != NULL) {
- schema_view->data_type = NANOARROW_TYPE_DICTIONARY;
+ schema_view->type = NANOARROW_TYPE_DICTIONARY;
}
- result = ArrowSchemaViewValidate(schema_view,
schema_view->storage_data_type, error);
+ result = ArrowSchemaViewValidate(schema_view, schema_view->storage_type,
error);
if (result != NANOARROW_OK) {
return result;
}
- if (schema_view->storage_data_type != schema_view->data_type) {
- result = ArrowSchemaViewValidate(schema_view, schema_view->data_type,
error);
+ if (schema_view->storage_type != schema_view->type) {
+ result = ArrowSchemaViewValidate(schema_view, schema_view->type, error);
if (result != NANOARROW_OK) {
return result;
}
}
- ArrowLayoutInit(&schema_view->layout, schema_view->storage_data_type);
- if (schema_view->storage_data_type == NANOARROW_TYPE_FIXED_SIZE_BINARY) {
+ ArrowLayoutInit(&schema_view->layout, schema_view->storage_type);
+ if (schema_view->storage_type == NANOARROW_TYPE_FIXED_SIZE_BINARY) {
schema_view->layout.element_size_bits[1] = schema_view->fixed_size * 8;
- } else if (schema_view->storage_data_type == NANOARROW_TYPE_FIXED_SIZE_LIST)
{
+ } else if (schema_view->storage_type == NANOARROW_TYPE_FIXED_SIZE_LIST) {
schema_view->layout.child_size_elements = schema_view->fixed_size;
}
@@ -1380,17 +1387,16 @@ ArrowErrorCode ArrowSchemaViewInit(struct
ArrowSchemaView* schema_view,
static int64_t ArrowSchemaTypeToStringInternal(struct ArrowSchemaView*
schema_view,
char* out, int64_t n) {
- const char* type_string = ArrowTypeString(schema_view->data_type);
- switch (schema_view->data_type) {
+ const char* type_string = ArrowTypeString(schema_view->type);
+ switch (schema_view->type) {
case NANOARROW_TYPE_DECIMAL128:
case NANOARROW_TYPE_DECIMAL256:
return snprintf(out, n, "%s(%d, %d)", type_string,
(int)schema_view->decimal_precision,
(int)schema_view->decimal_scale);
case NANOARROW_TYPE_TIMESTAMP:
- return snprintf(out, n, "%s('%s', '%.*s')", type_string,
- ArrowTimeUnitString(schema_view->time_unit),
- (int)schema_view->timezone.n_bytes,
schema_view->timezone.data);
+ return snprintf(out, n, "%s('%s', '%s')", type_string,
+ ArrowTimeUnitString(schema_view->time_unit),
schema_view->timezone);
case NANOARROW_TYPE_TIME32:
case NANOARROW_TYPE_TIME64:
case NANOARROW_TYPE_DURATION:
@@ -1426,23 +1432,24 @@ int64_t ArrowSchemaToString(struct ArrowSchema* schema,
char* out, int64_t n,
// Extension type and dictionary should include both the top-level type
// and the storage type.
- int is_extension = schema_view.extension_name.n_bytes > 0;
+ int is_extension = schema_view.extension_name.size_bytes > 0;
int is_dictionary = schema->dictionary != NULL;
int64_t n_chars = 0;
int64_t n_chars_last = 0;
// Uncommon but not technically impossible that both are true
if (is_extension && is_dictionary) {
- n_chars_last = snprintf(
- out + n_chars, n, "%.*s{dictionary(%s)<",
(int)schema_view.extension_name.n_bytes,
- schema_view.extension_name.data,
ArrowTypeString(schema_view.storage_data_type));
+ n_chars_last = snprintf(out + n_chars, n, "%.*s{dictionary(%s)<",
+ (int)schema_view.extension_name.size_bytes,
+ schema_view.extension_name.data,
+ ArrowTypeString(schema_view.storage_type));
} else if (is_extension) {
n_chars_last =
- snprintf(out + n_chars, n, "%.*s{",
(int)schema_view.extension_name.n_bytes,
+ snprintf(out + n_chars, n, "%.*s{",
(int)schema_view.extension_name.size_bytes,
schema_view.extension_name.data);
} else if (is_dictionary) {
n_chars_last = snprintf(out + n_chars, n, "dictionary(%s)<",
- ArrowTypeString(schema_view.storage_data_type));
+ ArrowTypeString(schema_view.storage_type));
}
n_chars += n_chars_last;
@@ -1550,7 +1557,7 @@ ArrowErrorCode ArrowMetadataReaderRead(struct
ArrowMetadataReader* reader,
pos += sizeof(int32_t);
key_out->data = reader->metadata + reader->offset + pos;
- key_out->n_bytes = key_size;
+ key_out->size_bytes = key_size;
pos += key_size;
int32_t value_size;
@@ -1558,7 +1565,7 @@ ArrowErrorCode ArrowMetadataReaderRead(struct
ArrowMetadataReader* reader,
pos += sizeof(int32_t);
value_out->data = reader->metadata + reader->offset + pos;
- value_out->n_bytes = value_size;
+ value_out->size_bytes = value_size;
pos += value_size;
reader->offset += pos;
@@ -1578,7 +1585,7 @@ int64_t ArrowMetadataSizeOf(const char* metadata) {
int64_t size = sizeof(int32_t);
while (ArrowMetadataReaderRead(&reader, &key, &value) == NANOARROW_OK) {
- size += sizeof(int32_t) + key.n_bytes + sizeof(int32_t) + value.n_bytes;
+ size += sizeof(int32_t) + key.size_bytes + sizeof(int32_t) +
value.size_bytes;
}
return size;
@@ -1594,11 +1601,11 @@ static ArrowErrorCode
ArrowMetadataGetValueInternal(const char* metadata,
while (ArrowMetadataReaderRead(&reader, &existing_key, &existing_value) ==
NANOARROW_OK) {
- int key_equal = key->n_bytes == existing_key.n_bytes &&
- strncmp(key->data, existing_key.data,
existing_key.n_bytes) == 0;
+ int key_equal = key->size_bytes == existing_key.size_bytes &&
+ strncmp(key->data, existing_key.data,
existing_key.size_bytes) == 0;
if (key_equal) {
value_out->data = existing_value.data;
- value_out->n_bytes = existing_value.n_bytes;
+ value_out->size_bytes = existing_value.size_bytes;
break;
}
}
@@ -1645,8 +1652,8 @@ static ArrowErrorCode
ArrowMetadataBuilderAppendInternal(struct ArrowBuffer* buf
int32_t n_keys;
memcpy(&n_keys, buffer->data, sizeof(int32_t));
- int32_t key_size = (int32_t)key->n_bytes;
- int32_t value_size = (int32_t)value->n_bytes;
+ int32_t key_size = (int32_t)key->size_bytes;
+ int32_t value_size = (int32_t)value->size_bytes;
NANOARROW_RETURN_NOT_OK(ArrowBufferReserve(
buffer, sizeof(int32_t) + key_size + sizeof(int32_t) + value_size));
@@ -1694,9 +1701,9 @@ static ArrowErrorCode
ArrowMetadataBuilderSetInternal(struct ArrowBuffer* buffer
return result;
}
- if (key->n_bytes == existing_key.n_bytes &&
+ if (key->size_bytes == existing_key.size_bytes &&
strncmp((const char*)key->data, (const char*)existing_key.data,
- existing_key.n_bytes) == 0) {
+ existing_key.size_bytes) == 0) {
result = ArrowMetadataBuilderAppendInternal(&new_buffer, key, value);
value = NULL;
} else {
@@ -2060,7 +2067,7 @@ static ArrowErrorCode ArrowArrayReserveInternal(struct
ArrowArray* array,
}
int64_t additional_size_bytes =
- array_view->buffer_views[i].n_bytes - ArrowArrayBuffer(array,
i)->size_bytes;
+ array_view->buffer_views[i].size_bytes - ArrowArrayBuffer(array,
i)->size_bytes;
if (additional_size_bytes > 0) {
NANOARROW_RETURN_NOT_OK(
@@ -2147,7 +2154,7 @@ static ArrowErrorCode ArrowArrayCheckInternalBufferSizes(
continue;
}
- int64_t expected_size = array_view->buffer_views[i].n_bytes;
+ int64_t expected_size = array_view->buffer_views[i].size_bytes;
int64_t actual_size = ArrowArrayBuffer(array, i)->size_bytes;
if (actual_size < expected_size) {
@@ -2248,7 +2255,7 @@ ArrowErrorCode ArrowArrayViewInitFromSchema(struct
ArrowArrayView* array_view,
return result;
}
- ArrowArrayViewInitFromType(array_view, schema_view.storage_data_type);
+ ArrowArrayViewInitFromType(array_view, schema_view.storage_type);
array_view->layout = schema_view.layout;
result = ArrowArrayViewAllocateChildren(array_view, schema->n_children);
@@ -2311,25 +2318,25 @@ void ArrowArrayViewSetLength(struct ArrowArrayView*
array_view, int64_t length)
switch (array_view->layout.buffer_type[i]) {
case NANOARROW_BUFFER_TYPE_VALIDITY:
- array_view->buffer_views[i].n_bytes = _ArrowBytesForBits(length);
+ array_view->buffer_views[i].size_bytes = _ArrowBytesForBits(length);
continue;
case NANOARROW_BUFFER_TYPE_DATA_OFFSET:
// Probably don't want/need to rely on the producer to have allocated
an
// offsets buffer of length 1 for a zero-size array
- array_view->buffer_views[i].n_bytes =
+ array_view->buffer_views[i].size_bytes =
(length != 0) * element_size_bytes * (length + 1);
continue;
case NANOARROW_BUFFER_TYPE_DATA:
- array_view->buffer_views[i].n_bytes =
+ array_view->buffer_views[i].size_bytes =
_ArrowRoundUpToMultipleOf8(array_view->layout.element_size_bits[i]
* length) /
8;
continue;
case NANOARROW_BUFFER_TYPE_TYPE_ID:
case NANOARROW_BUFFER_TYPE_UNION_OFFSET:
- array_view->buffer_views[i].n_bytes = element_size_bytes * length;
+ array_view->buffer_views[i].size_bytes = element_size_bytes * length;
continue;
case NANOARROW_BUFFER_TYPE_NONE:
- array_view->buffer_views[i].n_bytes = 0;
+ array_view->buffer_views[i].size_bytes = 0;
continue;
}
}
@@ -2368,7 +2375,7 @@ ArrowErrorCode ArrowArrayViewSetArray(struct
ArrowArrayView* array_view,
// If the null_count is 0, the validity buffer can be NULL
if (array_view->layout.buffer_type[i] == NANOARROW_BUFFER_TYPE_VALIDITY &&
array->null_count == 0 && array->buffers[i] == NULL) {
- array_view->buffer_views[i].n_bytes = 0;
+ array_view->buffer_views[i].size_bytes = 0;
}
array_view->buffer_views[i].data.data = array->buffers[i];
@@ -2389,18 +2396,18 @@ ArrowErrorCode ArrowArrayViewSetArray(struct
ArrowArrayView* array_view,
switch (array_view->storage_type) {
case NANOARROW_TYPE_STRING:
case NANOARROW_TYPE_BINARY:
- if (array_view->buffer_views[1].n_bytes != 0) {
+ if (array_view->buffer_views[1].size_bytes != 0) {
last_offset =
array_view->buffer_views[1].data.as_int32[array->offset +
array->length];
- array_view->buffer_views[2].n_bytes = last_offset;
+ array_view->buffer_views[2].size_bytes = last_offset;
}
break;
case NANOARROW_TYPE_LARGE_STRING:
case NANOARROW_TYPE_LARGE_BINARY:
- if (array_view->buffer_views[1].n_bytes != 0) {
+ if (array_view->buffer_views[1].size_bytes != 0) {
last_offset =
array_view->buffer_views[1].data.as_int64[array->offset +
array->length];
- array_view->buffer_views[2].n_bytes = last_offset;
+ array_view->buffer_views[2].size_bytes = last_offset;
}
break;
case NANOARROW_TYPE_STRUCT:
@@ -2426,7 +2433,7 @@ ArrowErrorCode ArrowArrayViewSetArray(struct
ArrowArrayView* array_view,
return EINVAL;
}
- if (array_view->buffer_views[1].n_bytes != 0) {
+ if (array_view->buffer_views[1].size_bytes != 0) {
last_offset =
array_view->buffer_views[1].data.as_int32[array->offset +
array->length];
if (array->children[0]->length < last_offset) {
@@ -2448,7 +2455,7 @@ ArrowErrorCode ArrowArrayViewSetArray(struct
ArrowArrayView* array_view,
return EINVAL;
}
- if (array_view->buffer_views[1].n_bytes != 0) {
+ if (array_view->buffer_views[1].size_bytes != 0) {
last_offset =
array_view->buffer_views[1].data.as_int64[array->offset +
array->length];
if (array->children[0]->length < last_offset) {
diff --git a/c/vendor/nanoarrow/nanoarrow.h b/c/vendor/nanoarrow/nanoarrow.h
index 7f29e71..8fd74a0 100644
--- a/c/vendor/nanoarrow/nanoarrow.h
+++ b/c/vendor/nanoarrow/nanoarrow.h
@@ -29,8 +29,6 @@
// #define NANOARROW_NAMESPACE YourNamespaceHere
-#define NANOARROW_BUILD_ID "gha695f08d7a07a64c0e13eb3444d61b2a6a8d8e5df"
-
#endif
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
@@ -388,13 +386,13 @@ enum ArrowBufferType {
struct ArrowStringView {
/// \brief A pointer to the start of the string
///
- /// If n_bytes is 0, this value may be NULL.
+ /// If size_bytes is 0, this value may be NULL.
const char* data;
/// \brief The size of the string in bytes,
///
/// (Not including the null terminator.)
- int64_t n_bytes;
+ int64_t size_bytes;
};
/// \brief Return a view of a const C string
@@ -404,9 +402,9 @@ static inline struct ArrowStringView ArrowCharView(const
char* value) {
out.data = value;
if (value) {
- out.n_bytes = (int64_t)strlen(value);
+ out.size_bytes = (int64_t)strlen(value);
} else {
- out.n_bytes = 0;
+ out.size_bytes = 0;
}
return out;
@@ -417,7 +415,7 @@ static inline struct ArrowStringView ArrowCharView(const
char* value) {
struct ArrowBufferView {
/// \brief A pointer to the start of the buffer
///
- /// If n_bytes is 0, this value may be NULL.
+ /// If size_bytes is 0, this value may be NULL.
union {
const void* data;
const int8_t* as_int8;
@@ -434,7 +432,7 @@ struct ArrowBufferView {
} data;
/// \brief The size of the buffer in bytes
- int64_t n_bytes;
+ int64_t size_bytes;
};
/// \brief Array buffer allocation and deallocation
@@ -600,7 +598,7 @@ struct ArrowArrayPrivateData {
// If using CMake, optionally pass -DNANOARROW_NAMESPACE=MyNamespace which
will set this
-// define in build_id.h. If not, you can optionally #define NANOARROW_NAMESPACE
+// define in nanoarrow_config.h. If not, you can optionally #define
NANOARROW_NAMESPACE
// MyNamespace here.
// This section remaps the non-prefixed symbols to the prefixed symbols so that
@@ -610,7 +608,6 @@ struct ArrowArrayPrivateData {
#define NANOARROW_CAT(A, B) A##B
#define NANOARROW_SYMBOL(A, B) NANOARROW_CAT(A, B)
-#define ArrowNanoarrowBuildId NANOARROW_SYMBOL(NANOARROW_NAMESPACE,
ArrowNanoarrowBuildId)
#define ArrowNanoarrowVersion NANOARROW_SYMBOL(NANOARROW_NAMESPACE,
ArrowNanoarrowVersion)
#define ArrowNanoarrowVersionInt \
NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowNanoarrowVersionInt)
@@ -776,9 +773,6 @@ const char* ArrowErrorMessage(struct ArrowError* error);
///
/// @{
-/// \brief Return the build id against which the library was compiled
-const char* ArrowNanoarrowBuildId(void);
-
/// \brief Return a version string in the form "major.minor.patch"
const char* ArrowNanoarrowVersion();
@@ -842,44 +836,42 @@ ArrowErrorCode ArrowSchemaSetTypeStruct(struct
ArrowSchema* schema, int64_t n_ch
/// \brief Set the format field of a fixed-size schema
///
-/// Returns EINVAL for fixed_size <= 0 or for data_type that is not
+/// Returns EINVAL for fixed_size <= 0 or for type that is not
/// NANOARROW_TYPE_FIXED_SIZE_BINARY or NANOARROW_TYPE_FIXED_SIZE_LIST.
/// For NANOARROW_TYPE_FIXED_SIZE_LIST, the appropriate number of children are
/// allocated, initialized, and named; however, the caller must
/// ArrowSchemaSetType() the first child. Schema must have been initialized
using
/// ArrowSchemaInit() or ArrowSchemaDeepCopy().
ArrowErrorCode ArrowSchemaSetTypeFixedSize(struct ArrowSchema* schema,
- enum ArrowType data_type, int32_t
fixed_size);
+ enum ArrowType type, int32_t
fixed_size);
/// \brief Set the format field of a decimal schema
///
-/// Returns EINVAL for scale <= 0 or for data_type that is not
+/// Returns EINVAL for scale <= 0 or for type that is not
/// NANOARROW_TYPE_DECIMAL128 or NANOARROW_TYPE_DECIMAL256. Schema must have
been
/// initialized using ArrowSchemaInit() or ArrowSchemaDeepCopy().
-ArrowErrorCode ArrowSchemaSetTypeDecimal(struct ArrowSchema* schema,
- enum ArrowType data_type,
+ArrowErrorCode ArrowSchemaSetTypeDecimal(struct ArrowSchema* schema, enum
ArrowType type,
int32_t decimal_precision,
int32_t decimal_scale);
/// \brief Set the format field of a time, timestamp, or duration schema
///
-/// Returns EINVAL for data_type that is not
+/// Returns EINVAL for type that is not
/// NANOARROW_TYPE_TIME32, NANOARROW_TYPE_TIME64,
/// NANOARROW_TYPE_TIMESTAMP, or NANOARROW_TYPE_DURATION. The
-/// timezone parameter must be NULL for a non-timestamp data_type. Schema must
have been
+/// timezone parameter must be NULL for a non-timestamp type. Schema must have
been
/// initialized using ArrowSchemaInit() or ArrowSchemaDeepCopy().
-ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema,
- enum ArrowType data_type,
+ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema, enum
ArrowType type,
enum ArrowTimeUnit time_unit,
const char* timezone);
/// \brief Seet the format field of a union schema
///
-/// Returns EINVAL for a data_type that is not NANOARROW_TYPE_DENSE_UNION
+/// Returns EINVAL for a type that is not NANOARROW_TYPE_DENSE_UNION
/// or NANOARROW_TYPE_SPARSE_UNION. The specified number of children are
/// allocated, and initialized.
-ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema,
- enum ArrowType data_type, int64_t
n_children);
+ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema, enum
ArrowType type,
+ int64_t n_children);
/// \brief Make a (recursive) copy of a schema
///
@@ -1008,14 +1000,14 @@ struct ArrowSchemaView {
/// This value will never be NANOARROW_TYPE_EXTENSION (see
/// extension_name and/or extension_metadata to check for
/// an extension type).
- enum ArrowType data_type;
+ enum ArrowType type;
/// \brief The storage data type represented by the schema
///
/// This value will never be NANOARROW_TYPE_DICTIONARY,
NANOARROW_TYPE_EXTENSION
/// or any datetime type. This value represents only the type required to
/// interpret the buffers in the array.
- enum ArrowType storage_data_type;
+ enum ArrowType storage_type;
/// \brief The storage layout represented by the schema
struct ArrowLayout layout;
@@ -1068,15 +1060,15 @@ struct ArrowSchemaView {
/// \brief Format timezone parameter
///
/// This value is set when parsing a timestamp type and represents
- /// the timezone format parameter. The ArrowStrintgView points to
- /// data within the schema and the value is undefined for other types.
- struct ArrowStringView timezone;
+ /// the timezone format parameter. This value points to
+ /// data within the schema and is undefined for other types.
+ const char* timezone;
/// \brief Union type ids parameter
///
/// This value is set when parsing a union type and represents
- /// type ids parameter. The ArrowStringView points to
- /// data within the schema and the value is undefined for other types.
+ /// type ids parameter. This value points to
+ /// data within the schema and is undefined for other types.
const char* union_type_ids;
};
@@ -1481,10 +1473,12 @@ void ArrowArrayViewReset(struct ArrowArrayView*
array_view);
static inline int8_t ArrowArrayViewIsNull(struct ArrowArrayView* array_view,
int64_t i);
/// \brief Get the type id of a union array element
-static inline int8_t ArrowArrayViewUnionTypeId(struct ArrowArrayView*
array_view, int64_t i);
+static inline int8_t ArrowArrayViewUnionTypeId(struct ArrowArrayView*
array_view,
+ int64_t i);
/// \brief Get the child index of a union array element
-static inline int8_t ArrowArrayViewUnionChildIndex(struct ArrowArrayView*
array_view, int64_t i);
+static inline int8_t ArrowArrayViewUnionChildIndex(struct ArrowArrayView*
array_view,
+ int64_t i);
/// \brief Get the index to use into the relevant union child array
static inline int64_t ArrowArrayViewUnionChildOffset(struct ArrowArrayView*
array_view,
@@ -1750,12 +1744,12 @@ static inline ArrowErrorCode
ArrowBufferAppendFloat(struct ArrowBuffer* buffer,
static inline ArrowErrorCode ArrowBufferAppendStringView(struct ArrowBuffer*
buffer,
struct
ArrowStringView value) {
- return ArrowBufferAppend(buffer, value.data, value.n_bytes);
+ return ArrowBufferAppend(buffer, value.data, value.size_bytes);
}
static inline ArrowErrorCode ArrowBufferAppendBufferView(struct ArrowBuffer*
buffer,
struct
ArrowBufferView value) {
- return ArrowBufferAppend(buffer, value.data.data, value.n_bytes);
+ return ArrowBufferAppend(buffer, value.data.data, value.size_bytes);
}
static inline ArrowErrorCode ArrowBufferAppendFill(struct ArrowBuffer* buffer,
@@ -2522,33 +2516,33 @@ static inline ArrowErrorCode
ArrowArrayAppendBytes(struct ArrowArray* array,
case NANOARROW_TYPE_STRING:
case NANOARROW_TYPE_BINARY:
offset = ((int32_t*)offset_buffer->data)[array->length];
- if ((offset + value.n_bytes) > INT32_MAX) {
+ if ((offset + value.size_bytes) > INT32_MAX) {
return EINVAL;
}
- offset += value.n_bytes;
+ offset += value.size_bytes;
NANOARROW_RETURN_NOT_OK(ArrowBufferAppend(offset_buffer, &offset,
sizeof(int32_t)));
NANOARROW_RETURN_NOT_OK(
- ArrowBufferAppend(data_buffer, value.data.data, value.n_bytes));
+ ArrowBufferAppend(data_buffer, value.data.data, value.size_bytes));
break;
case NANOARROW_TYPE_LARGE_STRING:
case NANOARROW_TYPE_LARGE_BINARY:
large_offset = ((int64_t*)offset_buffer->data)[array->length];
- large_offset += value.n_bytes;
+ large_offset += value.size_bytes;
NANOARROW_RETURN_NOT_OK(
ArrowBufferAppend(offset_buffer, &large_offset, sizeof(int64_t)));
NANOARROW_RETURN_NOT_OK(
- ArrowBufferAppend(data_buffer, value.data.data, value.n_bytes));
+ ArrowBufferAppend(data_buffer, value.data.data, value.size_bytes));
break;
case NANOARROW_TYPE_FIXED_SIZE_BINARY:
- if (value.n_bytes != fixed_size_bytes) {
+ if (value.size_bytes != fixed_size_bytes) {
return EINVAL;
}
NANOARROW_RETURN_NOT_OK(
- ArrowBufferAppend(data_buffer, value.data.data, value.n_bytes));
+ ArrowBufferAppend(data_buffer, value.data.data, value.size_bytes));
break;
default:
return EINVAL;
@@ -2569,7 +2563,7 @@ static inline ArrowErrorCode
ArrowArrayAppendString(struct ArrowArray* array,
struct ArrowBufferView buffer_view;
buffer_view.data.data = value.data;
- buffer_view.n_bytes = value.n_bytes;
+ buffer_view.size_bytes = value.size_bytes;
switch (private_data->storage_type) {
case NANOARROW_TYPE_STRING:
@@ -2833,20 +2827,22 @@ static inline struct ArrowStringView
ArrowArrayViewGetStringUnsafe(
case NANOARROW_TYPE_STRING:
case NANOARROW_TYPE_BINARY:
view.data = data_view + offsets_view->data.as_int32[i];
- view.n_bytes = offsets_view->data.as_int32[i + 1] -
offsets_view->data.as_int32[i];
+ view.size_bytes =
+ offsets_view->data.as_int32[i + 1] - offsets_view->data.as_int32[i];
break;
case NANOARROW_TYPE_LARGE_STRING:
case NANOARROW_TYPE_LARGE_BINARY:
view.data = data_view + offsets_view->data.as_int64[i];
- view.n_bytes = offsets_view->data.as_int64[i + 1] -
offsets_view->data.as_int64[i];
+ view.size_bytes =
+ offsets_view->data.as_int64[i + 1] - offsets_view->data.as_int64[i];
break;
case NANOARROW_TYPE_FIXED_SIZE_BINARY:
- view.n_bytes = array_view->layout.element_size_bits[1] / 8;
- view.data = array_view->buffer_views[1].data.as_char + (i *
view.n_bytes);
+ view.size_bytes = array_view->layout.element_size_bits[1] / 8;
+ view.data = array_view->buffer_views[1].data.as_char + (i *
view.size_bytes);
break;
default:
view.data = NULL;
- view.n_bytes = 0;
+ view.size_bytes = 0;
break;
}
@@ -2863,21 +2859,24 @@ static inline struct ArrowBufferView
ArrowArrayViewGetBytesUnsafe(
switch (array_view->storage_type) {
case NANOARROW_TYPE_STRING:
case NANOARROW_TYPE_BINARY:
- view.n_bytes = offsets_view->data.as_int32[i + 1] -
offsets_view->data.as_int32[i];
+ view.size_bytes =
+ offsets_view->data.as_int32[i + 1] - offsets_view->data.as_int32[i];
view.data.as_uint8 = data_view + offsets_view->data.as_int32[i];
break;
case NANOARROW_TYPE_LARGE_STRING:
case NANOARROW_TYPE_LARGE_BINARY:
- view.n_bytes = offsets_view->data.as_int64[i + 1] -
offsets_view->data.as_int64[i];
+ view.size_bytes =
+ offsets_view->data.as_int64[i + 1] - offsets_view->data.as_int64[i];
view.data.as_uint8 = data_view + offsets_view->data.as_int64[i];
break;
case NANOARROW_TYPE_FIXED_SIZE_BINARY:
- view.n_bytes = array_view->layout.element_size_bits[1] / 8;
- view.data.as_uint8 = array_view->buffer_views[1].data.as_uint8 + (i *
view.n_bytes);
+ view.size_bytes = array_view->layout.element_size_bits[1] / 8;
+ view.data.as_uint8 =
+ array_view->buffer_views[1].data.as_uint8 + (i * view.size_bytes);
break;
default:
view.data.data = NULL;
- view.n_bytes = 0;
+ view.size_bytes = 0;
break;
}
