Add tests for hash in strings

cpp/src/gandiva/gdv_function_stubs.cc

@@ -124,13 +124,14 @@ int32_t gdv_fn_populate_varlen_vector(int64_t context_ptr, int8_t* data_ptr,
 }
 
 GANDIVA_EXPORT
-char* gdv_fn_sha256_from_numeric(int64_t context, double value){
+const char * gdv_fn_sha256_from_numeric(int64_t context, double value){
   uint64_t value_as_long = gandiva::HashUtils::double_to_long(value);
 
   return gandiva::HashUtils::hash_using_SHA256(context, &value_as_long, sizeof(value_as_long));
 }
 
-char* gdv_fn_hash_sha256_from_string(int64_t context, const char* value, uint64_t value_length){
+GANDIVA_EXPORT
+const char * gdv_fn_hash_sha256_from_string(int64_t context, const char* value, uint64_t value_length){
   return gandiva::HashUtils::hash_using_SHA256(context, value, value_length);
 }
 
@@ -227,6 +228,17 @@ void ExportedStubFunctions::AddMappings(Engine* engine) const {
                                   types->i8_ptr_type() /*return_type*/, args,
                                   reinterpret_cast<void *>(gdv_fn_sha256_from_numeric));
 
+  // gdv_fn_hash_sha256_from_string
+  args = {
+      types->i64_type(),      // context
+      types->i8_ptr_type(),   // const char*
+      types->i64_type()       // value_length
+  };
+
+  engine->AddGlobalMappingForFunc("gdv_fn_hash_sha256_from_string",
+                                  types->i8_ptr_type() /*return_type*/, args,
+                                  reinterpret_cast<void *>(gdv_fn_hash_sha256_from_string));
+
   // gdv_fn_dec_to_string
   args = {
       types->i64_type(),      // context

cpp/src/gandiva/gdv_function_stubs.h

@@ -48,9 +48,9 @@ bool in_expr_lookup_utf8(int64_t ptr, const char* data, int data_len, bool in_va
 int gdv_fn_time_with_zone(int* time_fields, const char* zone, int zone_len,
                           int64_t* ret_time);
 
-char* gdv_fn_sha256_from_numeric(int64_t context, double value);
+const char * gdv_fn_sha256_from_numeric(int64_t context, double value);
 
-char* gdv_fn_hash_sha256_from_string(int64_t context, const char* value, uint64_t value_length);
+const char * gdv_fn_hash_sha256_from_string(int64_t context, const char* value, uint64_t value_length);
 
 int32_t gdv_fn_dec_from_string(int64_t context, const char* in, int32_t in_length,
                                int32_t* precision_from_str, int32_t* scale_from_str,

cpp/src/gandiva/gdv_function_stubs_test.cc

@@ -165,11 +165,39 @@ TEST(TestGdvFnStubs, TestSha256Numeric) {
 
   int64_t ctx_ptr = reinterpret_cast<int64_t>(&ctx);
 
-  char *zero_hash = gdv_fn_sha256_from_numeric(ctx_ptr, 0.0);
+  const char *zero_hash = gdv_fn_sha256_from_numeric(ctx_ptr, 0.0);
 
   EXPECT_STRNE(zero_hash, "");
   
   ctx.Reset();
 }
 
+TEST(TestGdvFnStubs, TestSha256String) {
+  gandiva::ExecutionContext ctx;
+
+  int64_t ctx_ptr = reinterpret_cast<int64_t>(&ctx);
+
+  const char *zero_hash = gdv_fn_sha256_from_numeric(ctx_ptr, 0.0);
+
+  const char *test_string = "hello world";
+
+  const char *first_sha_hash = gdv_fn_hash_sha256_from_string(ctx_ptr, test_string, strlen(test_string));
+  
+  EXPECT_STRNE(first_sha_hash, zero_hash);
+
+  const char *test_string_modified = "hello worlD";
+
+  const char
+      *second_sha_hash = gdv_fn_hash_sha256_from_string(ctx_ptr, test_string_modified, strlen(test_string_modified));
+
+  EXPECT_STRNE(second_sha_hash, first_sha_hash);
+
+  gdv_fn_hash_sha256_from_string(ctx_ptr, nullptr, 0);
+
+  EXPECT_THAT(ctx.get_error(),
+              ::testing::HasSubstr("A null value was given to be hashed."));
+
+  ctx.Reset();
+}
+
 }  // namespace gandiva

cpp/src/gandiva/hash_utils.cc

@@ -1,9 +1,15 @@
 #include <cstring>
 #include "gandiva/hash_utils.h"
 #include "openssl/evp.h"
+#include "execution_context.h"
 
 namespace gandiva {
-  char* HashUtils::hash_using_SHA256(int64_t context, const void *message, size_t message_length) {
+  const char * HashUtils::hash_using_SHA256(int64_t context, const void *message, size_t message_length) {
+    if(message == nullptr){
+      HashUtils::error_message(context, "A null value was given to be hashed.");
+      return "";
+    }
+
     EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();
 
     EVP_DigestInit_ex(md_ctx, EVP_sha256(), nullptr);
@@ -50,4 +56,9 @@ namespace gandiva {
   void HashUtils::clean_char_array(char *buffer) {
     buffer[0] = '\0';
   }
+
+  void HashUtils::error_message(int64_t context_ptr, char const *err_msg){
+    auto context = reinterpret_cast<gandiva::ExecutionContext*>(context_ptr);
+    context->set_error_msg(err_msg);
+  }
 }  // namespace gandiva

cpp/src/gandiva/hash_utils.h

@@ -8,12 +8,14 @@
 namespace gandiva {
   class GANDIVA_EXPORT HashUtils {
    public:
-    static char *hash_using_SHA256(int64_t context, const void *message, size_t message_length);
+    static const char * hash_using_SHA256(int64_t context, const void *message, size_t message_length);
 
     static uint64_t double_to_long(double value);
    private:
     static inline void clean_char_array(char *buffer);
+
+    static void error_message(int64_t context_ptr, char const *err_msg);
   };
-};
+}
 
 #endif //ARROW_SRC_HASH_UTILS_H_