From bb1998fdea5833e06f10d946fd2ae0f06a95e0ed Mon Sep 17 00:00:00 2001
From: Will Ayd <william.ayd@icloud.com>
Date: Fri, 10 Jan 2025 13:21:18 -0500
Subject: [PATCH 1/2] GH-45167: [C++] Implement Compute Equals for List Types

---
 .../arrow/compute/kernels/codegen_internal.h  | 55 ++++++++++++++++
 .../arrow/compute/kernels/scalar_compare.cc   |  8 +++
 .../compute/kernels/scalar_compare_test.cc    | 66 +++++++++++++++++++
 3 files changed, 129 insertions(+)

diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 2a492f581f53b..f420b31e78d34 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -141,6 +141,13 @@ struct GetViewType<Type, enable_if_t<is_base_binary_type<Type>::value ||
   static T LogicalValue(PhysicalType value) { return value; }
 };
 
+template <typename Type>
+struct GetViewType<Type, enable_if_list_type<Type>> {
+  using T = typename TypeTraits<Type>::ScalarType;
+
+  static T LogicalValue(T value) { return value; }
+};
+
 template <>
 struct GetViewType<Decimal32Type> {
   using T = Decimal32;
@@ -322,6 +329,32 @@ struct ArrayIterator<Type, enable_if_base_binary<Type>> {
   }
 };
 
+template <typename Type>
+struct ArrayIterator<Type, enable_if_list_type<Type>> {
+  using T = typename TypeTraits<Type>::ScalarType;
+  using ArrayT = typename TypeTraits<Type>::ArrayType;
+
+  const ArraySpan& arr;
+  const char* data;
+  const int32_t width;
+  int64_t position;
+
+  explicit ArrayIterator(const ArraySpan& arr)
+      : arr(arr),
+        data(reinterpret_cast<const char*>(arr.buffers[1].data)),
+        width(arr.type->byte_width()),
+        position(arr.offset) {}
+
+  T operator()() {
+    // TODO: how cann we avoid the ToArray call
+    const auto array_ptr = arr.ToArray();
+    const auto array = checked_cast<const ArrayT*>(array_ptr.get());
+    auto result = T{array->value_slice(position)};
+    position++;
+    return result;
+  }
+};
+
 template <>
 struct ArrayIterator<FixedSizeBinaryType> {
   const ArraySpan& arr;
@@ -390,6 +423,12 @@ struct UnboxScalar<Type, enable_if_has_string_view<Type>> {
   }
 };
 
+template <typename Type>
+struct UnboxScalar<Type, enable_if_list_type<Type>> {
+  using T = typename TypeTraits<Type>::ScalarType;
+  static const T& Unbox(const Scalar& val) { return checked_cast<const T&>(val); }
+};
+
 template <>
 struct UnboxScalar<Decimal32Type> {
   using T = Decimal32;
@@ -1383,6 +1422,22 @@ ArrayKernelExec GenerateDecimal(detail::GetTypeId get_id) {
   }
 }
 
+// Generate a kernel given a templated functor for list types
+//
+// See "Numeric" above for description of the generator functor
+template <template <typename...> class Generator, typename Type0, typename... Args>
+ArrayKernelExec GenerateList(detail::GetTypeId get_id) {
+  switch (get_id.id) {
+    case Type::LIST:
+      return Generator<Type0, ListType, Args...>::Exec;
+    case Type::LARGE_LIST:
+      return Generator<Type0, LargeListType, Args...>::Exec;
+    default:
+      DCHECK(false);
+      return nullptr;
+  }
+}
+
 // END of kernel generator-dispatchers
 // ----------------------------------------------------------------------
 // BEGIN of DispatchBest helpers
diff --git a/cpp/src/arrow/compute/kernels/scalar_compare.cc b/cpp/src/arrow/compute/kernels/scalar_compare.cc
index 9b2fd987d81d8..b0009f6985dbc 100644
--- a/cpp/src/arrow/compute/kernels/scalar_compare.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_compare.cc
@@ -445,6 +445,14 @@ std::shared_ptr<ScalarFunction> MakeCompareFunction(std::string name, FunctionDo
     DCHECK_OK(func->AddKernel({ty, ty}, boolean(), std::move(exec)));
   }
 
+  if constexpr (std::is_same_v<Op, Equal> || std::is_same_v<Op, NotEqual>) {
+    for (const auto id : {Type::LIST, Type::LARGE_LIST}) {
+      auto exec = GenerateList<applicator::ScalarBinaryEqualTypes, BooleanType, Op>(id);
+      DCHECK_OK(
+          func->AddKernel({InputType(id), InputType(id)}, boolean(), std::move(exec)));
+    }
+  }
+
   return func;
 }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_compare_test.cc b/cpp/src/arrow/compute/kernels/scalar_compare_test.cc
index 8f5952b40500a..4c102d3c7a84e 100644
--- a/cpp/src/arrow/compute/kernels/scalar_compare_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_compare_test.cc
@@ -680,6 +680,72 @@ TYPED_TEST(TestCompareDecimal, DifferentParameters) {
   }
 }
 
+template <typename ArrowType>
+class TestCompareList : public ::testing::Test {};
+TYPED_TEST_SUITE(TestCompareList, ListArrowTypes);
+
+TYPED_TEST(TestCompareList, ArrayScalar) {
+  auto value_typ = std::make_shared<Int32Type>();
+  auto ty = std::make_shared<TypeParam>(std::move(value_typ));
+
+  std::vector<std::pair<std::string, std::string>> cases = {
+      {"equal", "[1, 0, 0, null]"},
+      {"not_equal", "[0, 1, 1, null]"},
+  };
+  auto lhs = ArrayFromJSON(ty, R"([[1, 2, 3], [4, 5, 6], [42], null])");
+  auto rhs = ScalarFromJSON(ty, R"([1, 2, 3])");
+  for (const auto& op : cases) {
+    const auto& function = op.first;
+    const auto& expected = op.second;
+
+    SCOPED_TRACE(function);
+    CheckScalarBinary(function, lhs, rhs, ArrayFromJSON(boolean(), expected));
+  }
+}
+
+TYPED_TEST(TestCompareList, ScalarArray) {
+  auto value_typ = std::make_shared<Int32Type>();
+  auto ty = std::make_shared<TypeParam>(std::move(value_typ));
+
+  std::vector<std::pair<std::string, std::string>> cases = {
+      {"equal", "[1, 0, 0, null]"},
+      {"not_equal", "[0, 1, 1, null]"},
+  };
+  auto lhs = ScalarFromJSON(ty, R"([1, 2, 3])");
+  auto rhs = ArrayFromJSON(ty, R"([[1, 2, 3], [4, 5, 6], [42], null])");
+  for (const auto& op : cases) {
+    const auto& function = op.first;
+    const auto& expected = op.second;
+
+    SCOPED_TRACE(function);
+    CheckScalarBinary(function, lhs, rhs, ArrayFromJSON(boolean(), expected));
+  }
+}
+
+TYPED_TEST(TestCompareList, ArrayArray) {
+  auto value_typ = std::make_shared<Int32Type>();
+  auto ty = std::make_shared<TypeParam>(std::move(value_typ));
+
+  std::vector<std::pair<std::string, std::string>> cases = {
+      {"equal", "[1, 0, 0, null]"},
+      {"not_equal", "[0, 1, 1, null]"},
+  };
+  auto lhs = ArrayFromJSON(ty, R"([[1, 2, 3], [4, 5, 6], [7], null])");
+  auto rhs = ArrayFromJSON(ty, R"([[1, 2, 3], [4, 5], [6, 7, 8], null])");
+  for (const auto& op : cases) {
+    const auto& function = op.first;
+    const auto& expected = op.second;
+
+    SCOPED_TRACE(function);
+    CheckScalarBinary(function, ArrayFromJSON(ty, R"([])"), ArrayFromJSON(ty, R"([])"),
+                      ArrayFromJSON(boolean(), "[]"));
+    CheckScalarBinary(function, ArrayFromJSON(ty, R"([null])"),
+                      ArrayFromJSON(ty, R"([null])"), ArrayFromJSON(boolean(), "[null]"));
+
+    CheckScalarBinary(function, lhs, rhs, ArrayFromJSON(boolean(), expected));
+  }
+}
+
 // Helper to organize tests for fixed size binary comparisons
 struct CompareCase {
   std::shared_ptr<DataType> lhs_type;

From 649e3b0a093060d0f86caaeadcd9d3fd997af87b Mon Sep 17 00:00:00 2001
From: Will Ayd <william.ayd@icloud.com>
Date: Thu, 16 Jan 2025 15:03:10 -0500
Subject: [PATCH 2/2] Passing INT32 tests

---
 .../arrow/compute/kernels/codegen_internal.h  | 33 ++++++++++++++-----
 1 file changed, 24 insertions(+), 9 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index f420b31e78d34..575a8150b596a 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -333,24 +333,39 @@ template <typename Type>
 struct ArrayIterator<Type, enable_if_list_type<Type>> {
   using T = typename TypeTraits<Type>::ScalarType;
   using ArrayT = typename TypeTraits<Type>::ArrayType;
+  using offset_type = typename Type::offset_type;
 
   const ArraySpan& arr;
-  const char* data;
-  const int32_t width;
+  const offset_type* offsets;
+  offset_type cur_offset;
+  const ArraySpan& values;
+  const uint8_t* data;
   int64_t position;
 
   explicit ArrayIterator(const ArraySpan& arr)
       : arr(arr),
-        data(reinterpret_cast<const char*>(arr.buffers[1].data)),
-        width(arr.type->byte_width()),
+        offsets(reinterpret_cast<const offset_type*>(arr.buffers[1].data)),
+        cur_offset(offsets[arr.offset]),
+        values(arr.child_data[0]),
         position(arr.offset) {}
 
   T operator()() {
-    // TODO: how cann we avoid the ToArray call
-    const auto array_ptr = arr.ToArray();
-    const auto array = checked_cast<const ArrayT*>(array_ptr.get());
-    auto result = T{array->value_slice(position)};
-    position++;
+    offset_type next_offset = offsets[++position];
+    const auto len = next_offset - cur_offset;
+    const auto null_count = values.null_count;
+    const std::shared_ptr<Buffer> nulls_buffer =
+        null_count > 0 ? *values.buffers[0].owner : nullptr;
+    std::vector<std::shared_ptr<Buffer>> bufs = {nulls_buffer, *values.buffers[1].owner};
+    const auto child_offset = values.offset;
+
+    // TODO: do not hard code child type. also need to be aware of non-primitive children
+    const auto array_data = ArrayData::Make(int32(), len, std::move(bufs), null_count,
+                                            cur_offset + child_offset);
+    const auto array = MakeArray(array_data);
+    const auto result = T{array};
+
+    cur_offset = next_offset;
+
     return result;
   }
 };