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;