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

cpp/src/arrow/CMakeLists.txt

@@ -819,6 +819,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)