GH-47279: [C++] Implement GetByteRangesArray for view types (#47418)

### Rationale for this change

- Fix #47279

### What changes are included in this PR?

Add missing visit methods to GetByteRangesArray. The returned results are over
estimates since there's no cheap way to estimate offsets of the child
arrays/buffers. We can compute exact value if we are willing to check every
offset/view

### Are these changes tested?

Added tests

### Are there any user-facing changes?

No

* GitHub Issue: #47279

Lead-authored-by: Robert Kruszewski <github@robertk.io>
Co-authored-by: Rok Mihevc <rok@mihevc.org>
Signed-off-by: Rok Mihevc <rok@mihevc.org>

Author: robert3005

cpp/src/arrow/util/byte_size.cc

@@ -192,6 +192,35 @@ struct GetByteRangesArray {
 
   Status Visit(const LargeBinaryType& type) const { return VisitBaseBinary(type); }
 
+  template <typename BaseViewType>
+  Status VisitBaseViewType(const BaseViewType& type) const {
+    using c_type = typename BaseViewType::c_type;
+    RETURN_NOT_OK(VisitBitmap(input.buffers[0]));
+    const Buffer& views = *input.buffers[1];
+    RETURN_NOT_OK(range_starts->Append(reinterpret_cast<uint64_t>(views.data())));
+    RETURN_NOT_OK(range_offsets->Append(sizeof(c_type) * offset));
+    RETURN_NOT_OK(range_lengths->Append(sizeof(c_type) * length));
+
+    // The following calculation is an over estimate of the size since views buffer
+    // might
+    // 1. Not reference all the values in data buffers (the array was filtered without gc)
+    // 2. Reference a value multiple times without repeating it in the data buffer
+    //
+    // Producing exact byte size would require linear scan of all values in view buffer
+    for (size_t i = 2; i < input.buffers.size(); i++) {
+      const Buffer& buf = *input.buffers[i];
+      RETURN_NOT_OK(range_starts->Append(reinterpret_cast<uint64_t>(buf.data())));
+      RETURN_NOT_OK(range_offsets->Append(0));
+      RETURN_NOT_OK(range_lengths->Append(static_cast<uint64_t>(buf.size())));
+    }
+
+    return Status::OK();
+  }
+
+  Status Visit(const StringViewType& type) const { return VisitBaseViewType(type); }
+
+  Status Visit(const BinaryViewType& type) const { return VisitBaseViewType(type); }
+
   template <typename BaseListType>
   Status VisitBaseList(const BaseListType& type) const {
     using offset_type = typename BaseListType::offset_type;
@@ -215,6 +244,39 @@ struct GetByteRangesArray {
 
   Status Visit(const LargeListType& type) const { return VisitBaseList(type); }
 
+  template <typename BaseListViewType>
+  Status VisitBaseListView(const BaseListViewType& type) const {
+    using offset_type = typename BaseListViewType::offset_type;
+    RETURN_NOT_OK(VisitBitmap(input.buffers[0]));
+
+    const Buffer& offsets_buffer = *input.buffers[1];
+    RETURN_NOT_OK(
+        range_starts->Append(reinterpret_cast<uint64_t>(offsets_buffer.data())));
+    RETURN_NOT_OK(range_offsets->Append(sizeof(offset_type) * offset));
+    RETURN_NOT_OK(range_lengths->Append(sizeof(offset_type) * length));
+
+    const Buffer& lengths_buffer = *input.buffers[2];
+    RETURN_NOT_OK(
+        range_starts->Append(reinterpret_cast<uint64_t>(lengths_buffer.data())));
+    RETURN_NOT_OK(range_offsets->Append(sizeof(offset_type) * offset));
+    RETURN_NOT_OK(range_lengths->Append(sizeof(offset_type) * length));
+
+    // The following calculation is an over estimate of the byte size since views
+    // buffer might
+    // 1. Not reference all the values in data buffers (the array was filtered without gc)
+    // 2. Reference a value multiple times without repeating it in the data buffer
+    //
+    // Producing exact byte size would require linear scan of all values in view buffer
+    GetByteRangesArray child{
+        *input.child_data[0], 0, input.child_data[0]->length, range_starts, range_offsets,
+        range_lengths};
+    return VisitTypeInline(*type.value_type(), &child);
+  }
+
+  Status Visit(const ListViewType& type) const { return VisitBaseListView(type); }
+
+  Status Visit(const LargeListViewType& type) const { return VisitBaseListView(type); }
+
   Status Visit(const FixedSizeListType& type) const {
     RETURN_NOT_OK(VisitBitmap(input.buffers[0]));
     GetByteRangesArray child{*input.child_data[0],

cpp/src/arrow/util/byte_size_test.cc

@@ -316,6 +316,83 @@ TEST(ByteRanges, FixedSizeList) {
   CheckBufferRanges(list_arr_with_nulls->Slice(4, 1), {{0, 0, 1}, {1, 1, 1}, {2, 8, 2}});
 }
 
+TEST(ByteRanges, StringViewType) {
+  std::shared_ptr<Array> str_view_arr = ArrayFromJSON(
+      utf8_view(), R"(["short", "a longer string that requires a buffer"])");
+  // First buffer is validity (null in this case), second is views (16 bytes per view),
+  // third is the data buffer for long strings
+  CheckBufferRanges(str_view_arr, {{0, 0, 32}, {1, 0, 38}});
+
+  std::shared_ptr<Array> str_view_with_nulls = ArrayFromJSON(
+      utf8_view(), R"(["short", null, "another long string that requires a buffer"])");
+  CheckBufferRanges(str_view_with_nulls, {{0, 0, 1}, {1, 0, 48}, {2, 0, 42}});
+
+  CheckBufferRanges(str_view_arr->Slice(1, 1), {{0, 16, 16}, {1, 0, 38}});
+  CheckBufferRanges(str_view_arr->Slice(0, 1), {{0, 0, 16}, {1, 0, 38}});
+  CheckBufferRanges(str_view_with_nulls->Slice(2, 1),
+                    {{0, 0, 1}, {1, 32, 16}, {2, 0, 42}});
+}
+
+TEST(ByteRanges, BinaryViewType) {
+  std::shared_ptr<Array> bin_view_arr =
+      ArrayFromJSON(binary_view(), R"(["ABCD", "EFGHIJKLMNOPQRSTUVWXYZ"])");
+  // Similar to string view: views buffer (16 bytes per view), then data buffers
+  CheckBufferRanges(bin_view_arr, {{0, 0, 32}, {1, 0, 22}});
+
+  std::shared_ptr<Array> bin_view_with_nulls =
+      ArrayFromJSON(binary_view(), R"(["AB", null, "CDEFGHIJKLMNOPQRSTUVWXYZ"])");
+  CheckBufferRanges(bin_view_with_nulls, {{0, 0, 1}, {1, 0, 48}, {2, 0, 24}});
+
+  CheckBufferRanges(bin_view_arr->Slice(1, 1), {{0, 16, 16}, {1, 0, 22}});
+  CheckBufferRanges(bin_view_with_nulls->Slice(2, 1),
+                    {{0, 0, 1}, {1, 32, 16}, {2, 0, 24}});
+}
+
+using ListViewArrowTypes = ::testing::Types<ListViewType, LargeListViewType>;
+template <typename Type>
+class ByteRangesListView : public ::testing::Test {};
+TYPED_TEST_SUITE(ByteRangesListView, ListViewArrowTypes);
+
+TYPED_TEST(ByteRangesListView, Basic) {
+  using offset_type = typename TypeParam::offset_type;
+  std::shared_ptr<DataType> type = std::make_shared<TypeParam>(int32());
+  std::shared_ptr<Array> list_view_arr = ArrayFromJSON(type, "[[1, 2], [3], [0]]");
+  // Offsets buffer, sizes buffer, then child data
+  CheckBufferRanges(
+      list_view_arr,
+      {{0, 0, 3 * sizeof(offset_type)}, {1, 0, 3 * sizeof(offset_type)}, {2, 0, 16}});
+
+  std::shared_ptr<Array> list_view_with_nulls =
+      ArrayFromJSON(type, "[[1, 2], null, [3, 4, 5]]");
+  CheckBufferRanges(list_view_with_nulls, {{0, 0, 1},
+                                           {1, 0, 3 * sizeof(offset_type)},
+                                           {2, 0, 3 * sizeof(offset_type)},
+                                           {3, 0, 20}});
+  CheckBufferRanges(list_view_arr->Slice(2, 1),
+                    {{0, 2 * sizeof(offset_type), sizeof(offset_type)},
+                     {1, 2 * sizeof(offset_type), sizeof(offset_type)},
+                     {2, 0, 16}});
+  CheckBufferRanges(list_view_with_nulls->Slice(2, 1),
+                    {{0, 0, 1},
+                     {1, 2 * sizeof(offset_type), sizeof(offset_type)},
+                     {2, 2 * sizeof(offset_type), sizeof(offset_type)},
+                     {3, 0, 20}});
+}
+
+TYPED_TEST(ByteRangesListView, NestedListView) {
+  using offset_type = typename TypeParam::offset_type;
+  std::shared_ptr<DataType> type =
+      std::make_shared<TypeParam>(std::make_shared<TypeParam>(int32()));
+  std::shared_ptr<Array> list_view_arr =
+      ArrayFromJSON(type, "[[[1], [2, 3]], [[4, 5, 6]], [[7]]]");
+  // Parent offsets, parent sizes, child offsets, child sizes, grandchild data
+  CheckBufferRanges(list_view_arr, {{0, 0, 3 * sizeof(offset_type)},
+                                    {1, 0, 3 * sizeof(offset_type)},
+                                    {2, 0, 4 * sizeof(offset_type)},
+                                    {3, 0, 4 * sizeof(offset_type)},
+                                    {4, 0, 28}});
+}
+
 TEST(ByteRanges, Map) {
   std::shared_ptr<Array> map_arr = ArrayFromJSON(
       map(utf8(), uint16()), R"([[["x", 1], ["y", 2]], [["x", 3], ["y", 4]]])");