You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by li...@apache.org on 2022/11/28 17:11:06 UTC
[arrow-nanoarrow] branch main updated: [C] Fix some MAP type support issues (#74)
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-nanoarrow.git
The following commit(s) were added to refs/heads/main by this push:
new bf2418a [C] Fix some MAP type support issues (#74)
bf2418a is described below
commit bf2418ab92053614ad3354f3386e56f393a6a0c8
Author: David Li <li...@gmail.com>
AuthorDate: Mon Nov 28 12:11:00 2022 -0500
[C] Fix some MAP type support issues (#74)
Generally, make sure MAP is consistent with LIST:
- MAP has 2 buffers (validity + offset)
- MAP must be finished like LIST
Co-authored-by: Dewey Dunnington <de...@fishandwhistle.net>
---
src/nanoarrow/array.c | 14 +++++----
src/nanoarrow/array_inline.h | 1 +
src/nanoarrow/array_test.cc | 71 ++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 81 insertions(+), 5 deletions(-)
diff --git a/src/nanoarrow/array.c b/src/nanoarrow/array.c
index 05b50ed..3cbfdd4 100644
--- a/src/nanoarrow/array.c
+++ b/src/nanoarrow/array.c
@@ -74,13 +74,13 @@ static ArrowErrorCode ArrowArraySetStorageType(struct ArrowArray* array,
case NANOARROW_TYPE_FIXED_SIZE_LIST:
case NANOARROW_TYPE_STRUCT:
- case NANOARROW_TYPE_MAP:
case NANOARROW_TYPE_SPARSE_UNION:
array->n_buffers = 1;
break;
case NANOARROW_TYPE_LIST:
case NANOARROW_TYPE_LARGE_LIST:
+ case NANOARROW_TYPE_MAP:
case NANOARROW_TYPE_BOOL:
case NANOARROW_TYPE_UINT8:
case NANOARROW_TYPE_INT8:
@@ -648,9 +648,12 @@ ArrowErrorCode ArrowArrayViewSetArray(struct ArrowArrayView* array_view,
}
break;
case NANOARROW_TYPE_LIST:
+ case NANOARROW_TYPE_MAP: {
+ const char* type_name =
+ array_view->storage_type == NANOARROW_TYPE_LIST ? "list" : "map";
if (array->n_children != 1) {
- ArrowErrorSet(error, "Expected 1 child of list array but found %d child arrays",
- (int)array->n_children);
+ ArrowErrorSet(error, "Expected 1 child of %s array but found %d child arrays",
+ type_name, (int)array->n_children);
return EINVAL;
}
@@ -660,13 +663,14 @@ ArrowErrorCode ArrowArrayViewSetArray(struct ArrowArrayView* array_view,
if (array->children[0]->length < last_offset) {
ArrowErrorSet(
error,
- "Expected child of list array with length >= %ld but found array with "
+ "Expected child of %s array with length >= %ld but found array with "
"length %ld",
- (long)last_offset, (long)array->children[0]->length);
+ type_name, (long)last_offset, (long)array->children[0]->length);
return EINVAL;
}
}
break;
+ }
case NANOARROW_TYPE_LARGE_LIST:
if (array->n_children != 1) {
ArrowErrorSet(error,
diff --git a/src/nanoarrow/array_inline.h b/src/nanoarrow/array_inline.h
index 254b842..5a127b1 100644
--- a/src/nanoarrow/array_inline.h
+++ b/src/nanoarrow/array_inline.h
@@ -401,6 +401,7 @@ static inline ArrowErrorCode ArrowArrayFinishElement(struct ArrowArray* array) {
switch (private_data->storage_type) {
case NANOARROW_TYPE_LIST:
+ case NANOARROW_TYPE_MAP:
child_length = array->children[0]->length;
if (child_length > INT32_MAX) {
return EINVAL;
diff --git a/src/nanoarrow/array_test.cc b/src/nanoarrow/array_test.cc
index c3dc1ef..ae1d0e9 100644
--- a/src/nanoarrow/array_test.cc
+++ b/src/nanoarrow/array_test.cc
@@ -849,6 +849,77 @@ TEST(ArrayTest, ArrayTestAppendToLargeListArray) {
EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe()));
}
+TEST(ArrayTest, ArrayTestAppendToMapArray) {
+ struct ArrowArray array;
+ struct ArrowSchema schema;
+ struct ArrowError error;
+
+ ASSERT_EQ(ArrowSchemaInit(&schema, NANOARROW_TYPE_MAP), NANOARROW_OK);
+ ASSERT_EQ(ArrowSchemaAllocateChildren(&schema, 1), NANOARROW_OK);
+ ASSERT_EQ(ArrowSchemaInit(schema.children[0], NANOARROW_TYPE_STRUCT), NANOARROW_OK);
+ ASSERT_EQ(ArrowSchemaSetName(schema.children[0], "entries"), NANOARROW_OK);
+ ASSERT_EQ(ArrowSchemaAllocateChildren(schema.children[0], 2), NANOARROW_OK);
+
+ ASSERT_EQ(ArrowSchemaInit(schema.children[0]->children[0], NANOARROW_TYPE_INT32),
+ NANOARROW_OK);
+ ASSERT_EQ(ArrowSchemaSetName(schema.children[0]->children[0], "key"), NANOARROW_OK);
+ ASSERT_EQ(ArrowSchemaInit(schema.children[0]->children[1], NANOARROW_TYPE_STRING),
+ NANOARROW_OK);
+ ASSERT_EQ(ArrowSchemaSetName(schema.children[0]->children[1], "value"), NANOARROW_OK);
+
+ ASSERT_EQ(ArrowArrayInitFromSchema(&array, &schema, nullptr), NANOARROW_OK);
+
+ ASSERT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
+
+ // Check that we can reserve recursively without erroring
+ ASSERT_EQ(ArrowArrayReserve(&array, 5), NANOARROW_OK);
+ EXPECT_EQ(ArrowArrayBuffer(array.children[0], 1)->capacity_bytes, 0);
+
+ struct ArrowStringView string_value = ArrowCharView("foobar");
+ ASSERT_EQ(ArrowArrayAppendInt(array.children[0]->children[0], 123), NANOARROW_OK);
+ ASSERT_EQ(ArrowArrayAppendString(array.children[0]->children[1], string_value),
+ NANOARROW_OK);
+ EXPECT_EQ(ArrowArrayFinishElement(array.children[0]), NANOARROW_OK);
+ EXPECT_EQ(ArrowArrayFinishElement(&array), NANOARROW_OK);
+
+ ASSERT_EQ(ArrowArrayAppendNull(&array, 1), NANOARROW_OK);
+
+ // Make sure number of children is checked at finish
+ array.n_children = 0;
+ EXPECT_EQ(ArrowArrayFinishBuilding(&array, &error), EINVAL);
+ EXPECT_STREQ(ArrowErrorMessage(&error),
+ "Expected 1 child of map array but found 0 child arrays");
+ array.n_children = 1;
+
+ // Make sure final child size is checked at finish
+ array.children[0]->length = array.children[0]->length - 1;
+ EXPECT_EQ(ArrowArrayFinishBuilding(&array, &error), EINVAL);
+ EXPECT_STREQ(
+ ArrowErrorMessage(&error),
+ "Expected child of map array with length >= 1 but found array with length 0");
+
+ array.children[0]->length = array.children[0]->length + 1;
+ EXPECT_EQ(ArrowArrayFinishBuilding(&array, &error), NANOARROW_OK);
+
+ auto maybe_arrow_array = ImportArray(&array, &schema);
+ ARROW_EXPECT_OK(maybe_arrow_array);
+ auto arrow_array = std::move(maybe_arrow_array).MoveValueUnsafe();
+
+ auto key_builder = std::make_shared<Int32Builder>();
+ auto value_builder = std::make_shared<StringBuilder>();
+ auto builder =
+ MapBuilder(default_memory_pool(), key_builder, value_builder, map(int32(), utf8()));
+ ARROW_EXPECT_OK(builder.Append());
+ ARROW_EXPECT_OK(key_builder->Append(123));
+ ARROW_EXPECT_OK(value_builder->Append("foobar"));
+ ARROW_EXPECT_OK(builder.AppendNull());
+ auto maybe_expected_array = builder.Finish();
+ ARROW_EXPECT_OK(maybe_expected_array);
+ auto expected_array = std::move(maybe_expected_array).MoveValueUnsafe();
+
+ EXPECT_TRUE(arrow_array->Equals(expected_array));
+}
+
TEST(ArrayTest, ArrayTestAppendToFixedSizeListArray) {
struct ArrowArray array;
struct ArrowSchema schema;