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

cpp/src/arrow/CMakeLists.txt

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

@@ -181,6 +181,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,42 @@ 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 is an Array of length equal to the length of the input; however, the output
+/// shall be a UInt32Array, with each element being a hash constructed from each row of
+/// the input. If the input Array is a NestedArray, this means that each "attribute" or
+/// "field" of the input NestedArray corresponding to the same "row" will collectively
+/// produce a single uint32_t hash. At the moment, this function does not 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 is an Array of length equal to the length of the input; however, the output
+/// shall be a UInt64Array, with each element being a hash constructed from each row of
+/// the input. If the input Array is a NestedArray, this means that each "attribute" or
+/// "field" of the input NestedArray corresponding to the same "row" will collectively
+/// produce a single uint64_t hash. At the moment, this function does not 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)