GH-17211: [C++] Add hash32 and hash64 scalar compute functions

cpp/src/arrow/CMakeLists.txt

@@ -869,6 +869,7 @@ if(ARROW_COMPUTE)
  compute/kernels/scalar_arithmetic.cc
  compute/kernels/scalar_boolean.cc
  compute/kernels/scalar_compare.cc
+ compute/kernels/scalar_hash.cc
  compute/kernels/scalar_if_else.cc
  compute/kernels/scalar_nested.cc
  compute/kernels/scalar_random.cc

cpp/src/arrow/compute/CMakeLists.txt

@@ -185,6 +185,7 @@ add_arrow_compute_test(row_test
  arrow_compute_testing)
 
 add_arrow_compute_benchmark(function_benchmark)
+add_arrow_compute_benchmark(key_hash_benchmark)
 
 add_subdirectory(kernels)
 

cpp/src/arrow/compute/api_scalar.cc

@@ -957,6 +957,16 @@ Result<Datum> MapLookup(const Datum& arg, MapLookupOptions options, ExecContext*
  return CallFunction("map_lookup", {arg}, &options, ctx);
 }
 
+// ----------------------------------------------------------------------
+// Hash functions
+Result<Datum> Hash32(const Datum& input_array, ExecContext* ctx) {
+ return CallFunction("hash32", {input_array}, ctx);
+}
+
+Result<Datum> Hash64(const Datum& input_array, ExecContext* ctx) {
+ return CallFunction("hash64", {input_array}, ctx);
+}
+
 // ----------------------------------------------------------------------
 
 } // namespace compute

cpp/src/arrow/compute/api_scalar.h

@@ -1807,5 +1807,46 @@ ARROW_EXPORT Result<Datum> NanosecondsBetween(const Datum& left, const Datum& ri
 /// \note API not yet finalized
 ARROW_EXPORT Result<Datum> MapLookup(const Datum& map, MapLookupOptions options,
  ExecContext* ctx = NULLPTR);
+
+/// \brief Construct a hash value for each row of the input.
+///
+/// The result has the same length and shape as the input (Array in, Array out;
+/// ChunkedArray in, ChunkedArray out), but with element type UInt32. For a nested
+/// input type (struct, list, map, etc.), each row's child values are combined into a
+/// single hash for that row, recursively. A null input row produces a null output row;
+/// within a struct, a null field makes that whole row null, while within a list or map a
+/// null element does not (only the row's own validity matters there). Hash values are not
+/// guaranteed to be stable across different versions of the library, and this function
+/// does not currently take options, though these may be added in the future.
+///
+/// \param[in] input_array input data to hash
+/// \param[in] ctx function execution context, optional
+/// \return elementwise hash values
+///
+/// \since 26.0.0
+/// \note API not yet finalized
+ARROW_EXPORT
+Result<Datum> Hash32(const Datum& input_array, ExecContext* ctx = NULLPTR);
+
+/// \brief Construct a hash value for each row of the input.
+///
+/// The result has the same length and shape as the input (Array in, Array out;
+/// ChunkedArray in, ChunkedArray out), but with element type UInt64. For a nested
+/// input type (struct, list, map, etc.), each row's child values are combined into a
+/// single hash for that row, recursively. A null input row produces a null output row;
+/// within a struct, a null field makes that whole row null, while within a list or map a
+/// null element does not (only the row's own validity matters there). Hash values are not
+/// guaranteed to be stable across different versions of the library, and this function
+/// does not currently take options, though these may be added in the future.
+///
+/// \param[in] input_array input data to hash
+/// \param[in] ctx function execution context, optional
+/// \return elementwise hash values
+///
+/// \since 26.0.0
+/// \note API not yet finalized
+ARROW_EXPORT
+Result<Datum> Hash64(const Datum& input_array, ExecContext* ctx = NULLPTR);
+
 } // namespace compute
 } // namespace arrow

cpp/src/arrow/compute/initialize.cc

@@ -31,6 +31,7 @@ Status RegisterComputeKernels() {
  internal::RegisterScalarArithmetic(registry);
  internal::RegisterScalarBoolean(registry);
  internal::RegisterScalarComparison(registry);
+ internal::RegisterScalarHash(registry);
  internal::RegisterScalarIfElse(registry);
  internal::RegisterScalarNested(registry);
  internal::RegisterScalarRandom(registry); // Nullary

cpp/src/arrow/compute/kernels/CMakeLists.txt

@@ -77,6 +77,7 @@ add_arrow_compute_test(scalar_math_test
 
 add_arrow_compute_test(scalar_utility_test
  SOURCES
+ scalar_hash_test.cc
  scalar_random_test.cc
  scalar_set_lookup_test.cc
  scalar_validity_test.cc
@@ -89,6 +90,7 @@ add_arrow_benchmark(scalar_cast_benchmark PREFIX "arrow-compute")
 add_arrow_compute_benchmark(scalar_arithmetic_benchmark)
 add_arrow_compute_benchmark(scalar_boolean_benchmark)
 add_arrow_compute_benchmark(scalar_compare_benchmark)
+add_arrow_compute_benchmark(scalar_hash_benchmark)
 add_arrow_compute_benchmark(scalar_if_else_benchmark)
 add_arrow_compute_benchmark(scalar_list_benchmark)
 add_arrow_compute_benchmark(scalar_random_benchmark)

cpp/src/arrow/compute/kernels/meson.build

@@ -55,6 +55,7 @@ scalar_kernel_tests = {
  },
  'arrow-compute-scalar-utility-test': {
  'sources': [
+ 'scalar_hash_test.cc',
  'scalar_random_test.cc',
  'scalar_set_lookup_test.cc',
  'scalar_validity_test.cc',
@@ -76,6 +77,7 @@ scalar_kernel_benchmarks = [
  'scalar_boolean_benchmark',
  'scalar_cast_benchmark',
  'scalar_compare_benchmark',
+ 'scalar_hash_benchmark',
  'scalar_if_else_benchmark',
  'scalar_list_benchmark',
  'scalar_random_benchmark',