GH-37221: [C++] Refactor REE utilities with separating internal API, add flexible type matcher, and JSON support

cpp/src/arrow/CMakeLists.txt

@@ -772,7 +772,6 @@ if(ARROW_COMPUTE)
        compute/kernels/hash_aggregate_numeric.cc
        compute/kernels/hash_aggregate_pivot.cc
        compute/kernels/pivot_internal.cc
-       compute/kernels/ree_util_internal.cc
        compute/kernels/scalar_arithmetic.cc
        compute/kernels/scalar_boolean.cc
        compute/kernels/scalar_compare.cc

cpp/src/arrow/c/CMakeLists.txt

@@ -15,28 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
-# TODO(GH-37221): Remove compute dependency for REE requirements on bridge_test
-set(ARROW_TEST_LINK_LIBS "")
-
-if(ARROW_TEST_LINKAGE STREQUAL "static")
-  list(APPEND ARROW_TEST_LINK_LIBS ${ARROW_TEST_STATIC_LINK_LIBS})
-else()
-  list(APPEND ARROW_TEST_LINK_LIBS ${ARROW_TEST_SHARED_LINK_LIBS})
-endif()
-
-if(ARROW_COMPUTE)
-  if(ARROW_TEST_LINKAGE STREQUAL "static")
-    list(APPEND ARROW_TEST_LINK_LIBS arrow_compute_static arrow_compute_testing)
-  else()
-    list(APPEND ARROW_TEST_LINK_LIBS arrow_compute_shared arrow_compute_testing)
-  endif()
-endif()
-
-add_arrow_test(bridge_test
-               PREFIX
-               "arrow-c"
-               STATIC_LINK_LIBS
-               ${ARROW_TEST_LINK_LIBS})
+add_arrow_test(bridge_test PREFIX "arrow-c")
 add_arrow_test(dlpack_test)
 
 add_arrow_benchmark(bridge_benchmark)

cpp/src/arrow/c/bridge_test.cc

@@ -31,6 +31,7 @@
 #include "arrow/c/bridge.h"
 #include "arrow/c/helpers.h"
 #include "arrow/c/util_internal.h"
+#include "arrow/json/from_string.h"
 #include "arrow/memory_pool.h"
 #include "arrow/testing/builder.h"
 #include "arrow/testing/extension_type.h"
@@ -45,13 +46,9 @@
 #include "arrow/util/logging_internal.h"
 #include "arrow/util/macros.h"
 #include "arrow/util/range.h"
+#include "arrow/util/ree_util.h"
 #include "arrow/util/thread_pool.h"
 
-// TODO(GH-37221): Remove these ifdef checks when compute dependency is removed
-#ifdef ARROW_COMPUTE
-#  include "arrow/compute/api_vector.h"
-#endif
-
 namespace arrow {
 
 using internal::ArrayDeviceExportTraits;
@@ -472,7 +469,6 @@ TEST_F(TestSchemaExport, Union) {
              {ARROW_FLAG_NULLABLE});
 }
 
-#ifdef ARROW_COMPUTE
 TEST_F(TestSchemaExport, RunEndEncoded) {
   TestNested(run_end_encoded(int16(), uint8()), {"+r", "s", "C"},
              {"", "run_ends", "values"}, {ARROW_FLAG_NULLABLE, 0, ARROW_FLAG_NULLABLE});
@@ -484,7 +480,6 @@ TEST_F(TestSchemaExport, RunEndEncoded) {
              {"", "run_ends", "values", "item"},
              {ARROW_FLAG_NULLABLE, 0, ARROW_FLAG_NULLABLE, ARROW_FLAG_NULLABLE});
 }
-#endif
 
 std::string GetIndexFormat(Type::type type_id) {
   switch (type_id) {
@@ -1080,35 +1075,23 @@ TEST_F(TestArrayExport, Union) {
   TestNested(type, data);
 }
 
-#ifdef ARROW_COMPUTE
-Result<std::shared_ptr<Array>> REEFromJSON(const std::shared_ptr<DataType>& ree_type,
-                                           const std::string& json) {
-  auto ree_type_ptr = checked_cast<const RunEndEncodedType*>(ree_type.get());
-  auto array = ArrayFromJSON(ree_type_ptr->value_type(), json);
-  ARROW_ASSIGN_OR_RAISE(
-      auto datum,
-      RunEndEncode(array, compute::RunEndEncodeOptions{ree_type_ptr->run_end_type()}));
-  return datum.make_array();
-}
-
 TEST_F(TestArrayExport, RunEndEncoded) {
   auto factory = []() {
-    return REEFromJSON(run_end_encoded(int32(), int8()),
-                       "[1, 2, 2, 3, null, null, null, 4]");
+    return ArrayFromJSON(run_end_encoded(int32(), int8()),
+                         "[1, 2, 2, 3, null, null, null, 4]");
   };
   TestNested(factory);
 }
 
 TEST_F(TestArrayExport, RunEndEncodedSliced) {
   auto factory = []() -> Result<std::shared_ptr<Array>> {
     ARROW_ASSIGN_OR_RAISE(auto ree_array,
-                          REEFromJSON(run_end_encoded(int32(), int8()),
-                                      "[1, 2, 2, 3, null, null, null, 4]"));
+                          json::ArrayFromJSONString(run_end_encoded(int32(), int8()),
+                                                    "[1, 2, 2, 3, null, null, null, 4]"));
     return ree_array->Slice(1, 5);
   };
   TestNested(factory);
 }
-#endif
 
 TEST_F(TestArrayExport, Dictionary) {
   {
@@ -1432,16 +1415,14 @@ class TestDeviceArrayExport : public ::testing::Test {
     return [=]() { return ToDevice(mm, *ArrayFromJSON(type, json)->data()); };
   }
 
-#ifdef ARROW_COMPUTE
   static std::function<Result<std::shared_ptr<Array>>()> JSONREEArrayFactory(
       const std::shared_ptr<MemoryManager>& mm, std::shared_ptr<DataType> type,
       const char* json) {
     return [=]() -> Result<std::shared_ptr<Array>> {
-      ARROW_ASSIGN_OR_RAISE(auto result, REEFromJSON(type, json));
+      ARROW_ASSIGN_OR_RAISE(auto result, json::ArrayFromJSONString(type, json));
       return ToDevice(mm, *result->data());
     };
   }
-#endif
 
   template <typename ArrayFactory, typename ExportCheckFunc>
   void TestWithArrayFactory(ArrayFactory&& factory, ExportCheckFunc&& check_func) {
@@ -1680,7 +1661,6 @@ TEST_F(TestDeviceArrayExport, Union) {
   TestNested(mm, type, data);
 }
 
-#ifdef ARROW_COMPUTE
 TEST_F(TestDeviceArrayExport, RunEndEncoded) {
   std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
   auto mm = device->default_memory_manager();
@@ -1689,7 +1669,6 @@ TEST_F(TestDeviceArrayExport, RunEndEncoded) {
   const char* data = "[1, null, 2, 2, 4, 5]";
   TestNested(JSONREEArrayFactory(mm, type, data));
 }
-#endif
 
 TEST_F(TestDeviceArrayExport, Extension) {
   std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
@@ -2186,14 +2165,12 @@ TEST_F(TestSchemaImport, Map) {
   CheckImport(expected);
 }
 
-#ifdef ARROW_COMPUTE
 TEST_F(TestSchemaImport, RunEndEncoded) {
   FillPrimitive(AddChild(), "s", "run_ends");
   FillPrimitive(AddChild(), "I", "values");
   FillRunEndEncoded("+r");
   CheckImport(run_end_encoded(int16(), uint32()));
 }
-#endif
 
 TEST_F(TestSchemaImport, Dictionary) {
   FillPrimitive(AddChild(), "u");
@@ -3175,14 +3152,14 @@ TEST_F(TestArrayImport, Struct) {
   CheckImport(expected);
 }
 
-#ifdef ARROW_COMPUTE
 TEST_F(TestArrayImport, RunEndEncoded) {
   FillPrimitive(AddChild(), 5, 0, 0, run_ends_buffers5);
   FillPrimitive(AddChild(), 5, 0, 0, primitive_buffers_no_nulls5);
   FillRunEndEncoded(9, 0);
-  ASSERT_OK_AND_ASSIGN(auto expected,
-                       REEFromJSON(run_end_encoded(int16(), float32()),
-                                   "[0.0, 1.5, -2.0, -2.0, 3.0, 3.0, 3.0, 4.0, 4.0]"));
+  ASSERT_OK_AND_ASSIGN(
+      auto expected,
+      json::ArrayFromJSONString(run_end_encoded(int16(), float32()),
+                                "[0.0, 1.5, -2.0, -2.0, 3.0, 3.0, 3.0, 4.0, 4.0]"));
   ASSERT_OK(expected->ValidateFull());
   CheckImport(expected);
 }
@@ -3193,32 +3170,35 @@ TEST_F(TestArrayImport, RunEndEncodedWithOffset) {
   FillPrimitive(AddChild(), 3, 0, 2, run_ends_buffers5);
   FillPrimitive(AddChild(), 3, 0, 2, primitive_buffers_no_nulls5);
   FillRunEndEncoded(7, 0);
-  ASSERT_OK_AND_ASSIGN(auto expected,
-                       REEFromJSON(ree_type, "[-2.0, -2.0, -2.0, -2.0, 3.0, 3.0, 3.0]"));
+  ASSERT_OK_AND_ASSIGN(
+      auto expected,
+      json::ArrayFromJSONString(ree_type, "[-2.0, -2.0, -2.0, -2.0, 3.0, 3.0, 3.0]"));
   CheckImport(expected);
 
   // Offset in parent
   FillPrimitive(AddChild(), 5, 0, 0, run_ends_buffers5);
   FillPrimitive(AddChild(), 5, 0, 0, primitive_buffers_no_nulls5);
   FillRunEndEncoded(5, 2);
-  ASSERT_OK_AND_ASSIGN(expected, REEFromJSON(ree_type, "[-2.0, -2.0, 3.0, 3.0, 3.0]"));
+  ASSERT_OK_AND_ASSIGN(
+      expected, json::ArrayFromJSONString(ree_type, "[-2.0, -2.0, 3.0, 3.0, 3.0]"));
   CheckImport(expected);
 
   // Length in parent that cuts last run
   FillPrimitive(AddChild(), 5, 0, 0, run_ends_buffers5);
   FillPrimitive(AddChild(), 5, 0, 0, primitive_buffers_no_nulls5);
   FillRunEndEncoded(4, 2);
-  ASSERT_OK_AND_ASSIGN(expected, REEFromJSON(ree_type, "[-2.0, -2.0, 3.0, 3.0]"));
+  ASSERT_OK_AND_ASSIGN(expected,
+                       json::ArrayFromJSONString(ree_type, "[-2.0, -2.0, 3.0, 3.0]"));
   CheckImport(expected);
 
   // Offset in both children and parent
   FillPrimitive(AddChild(), 3, 0, 2, run_ends_buffers5);
   FillPrimitive(AddChild(), 3, 0, 2, primitive_buffers_no_nulls5);
   FillRunEndEncoded(4, 2);
-  ASSERT_OK_AND_ASSIGN(expected, REEFromJSON(ree_type, "[-2.0, -2.0, 3.0, 3.0]"));
+  ASSERT_OK_AND_ASSIGN(expected,
+                       json::ArrayFromJSONString(ree_type, "[-2.0, -2.0, 3.0, 3.0]"));
   CheckImport(expected);
 }
-#endif
 
 TEST_F(TestArrayImport, SparseUnion) {
   auto type = sparse_union({field("strs", utf8()), field("ints", int8())}, {43, 42});
@@ -3749,12 +3729,10 @@ TEST_F(TestSchemaRoundtrip, Union) {
   TestWithTypeFactory([&]() { return dense_union({f1, f2}, type_codes); });
 }
 
-#ifdef ARROW_COMPUTE
 TEST_F(TestSchemaRoundtrip, RunEndEncoded) {
   TestWithTypeFactory([]() { return run_end_encoded(int16(), float32()); });
   TestWithTypeFactory([]() { return run_end_encoded(int32(), list(float32())); });
 }
-#endif
 
 TEST_F(TestSchemaRoundtrip, Dictionary) {
   for (auto index_ty : all_dictionary_index_types()) {
@@ -4104,13 +4082,12 @@ TEST_F(TestArrayRoundtrip, Union) {
   }
 }
 
-#ifdef ARROW_COMPUTE
 TEST_F(TestArrayRoundtrip, RunEndEncoded) {
   {
     auto factory = []() -> Result<std::shared_ptr<Array>> {
-      ARROW_ASSIGN_OR_RAISE(auto ree_array,
-                            REEFromJSON(run_end_encoded(int32(), int8()),
-                                        "[1, 2, 2, 3, null, null, null, 4]"));
+      ARROW_ASSIGN_OR_RAISE(
+          auto ree_array, json::ArrayFromJSONString(run_end_encoded(int32(), int8()),
+                                                    "[1, 2, 2, 3, null, null, null, 4]"));
       return ree_array->Slice(1, 5);
     };
     TestWithArrayFactory(factory);
@@ -4130,7 +4107,6 @@ TEST_F(TestArrayRoundtrip, RunEndEncoded) {
     TestWithArrayFactory(factory);
   }
 }
-#endif
 
 TEST_F(TestArrayRoundtrip, Dictionary) {
   {

cpp/src/arrow/compute/kernel.cc

@@ -32,6 +32,7 @@
 #include "arrow/util/hash_util.h"
 #include "arrow/util/logging_internal.h"
 #include "arrow/util/macros.h"
+#include "arrow/util/ree_util.h"
 
 namespace arrow {
 
@@ -276,6 +277,27 @@ std::shared_ptr<TypeMatcher> FixedSizeBinaryLike() {
   return std::make_shared<FixedSizeBinaryLikeMatcher>();
 }
 
+class REEValueMatcher : public TypeMatcher {
+ public:
+  REEValueMatcher() {}
+
+  bool Matches(const DataType& type) const override {
+    return ree_util::internal::IsValueTypeSupported(type);
+  }
+
+  bool Equals(const TypeMatcher& other) const override {
+    if (this == &other) {
+      return true;
+    }
+    auto casted = dynamic_cast<const REEValueMatcher*>(&other);
+    return casted != nullptr;
+  }
+
+  std::string ToString() const override { return "ree-value"; }
+};
+
+std::shared_ptr<TypeMatcher> REEValue() { return std::make_shared<REEValueMatcher>(); }
+
 class RunEndIntegerMatcher : public TypeMatcher {
  public:
   ~RunEndIntegerMatcher() override = default;

cpp/src/arrow/compute/kernel.h

@@ -144,6 +144,10 @@ ARROW_EXPORT std::shared_ptr<TypeMatcher> LargeBinaryLike();
 // Match any fixed binary type
 ARROW_EXPORT std::shared_ptr<TypeMatcher> FixedSizeBinaryLike();
 
+/// \brief Match any type supported as a value type for run-end encoding
+/// (any non-nested type except Null)
+ARROW_EXPORT std::shared_ptr<TypeMatcher> REEValue();
+
 // \brief Match any primitive type (boolean or any type representable as a C
 // Type)
 ARROW_EXPORT std::shared_ptr<TypeMatcher> Primitive();