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,48 @@ 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 (Scalar in, Scalar out;
+/// 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 (Scalar in, Scalar out;
+/// 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',