implement json functions (apache#49)

Signed-off-by: Yuan Zhou <yuan.zhou@intel.com>

Author: zhouyuan

cpp/src/gandiva/CMakeLists.txt

@@ -83,6 +83,7 @@ set(SRC_FILES
     llvm_generator.cc
     llvm_types.cc
     like_holder.cc
+    json_holder.cc
     literal_holder.cc
     projector.cc
     regex_util.cc
@@ -229,6 +230,7 @@ add_gandiva_test(internals-test
                  lru_cache_test.cc
                  to_date_holder_test.cc
                  simple_arena_test.cc
+                 json_holder_test.cc
                  like_holder_test.cc
                  replace_holder_test.cc
                  decimal_type_util_test.cc

cpp/src/gandiva/function_holder_registry.h

@@ -25,6 +25,7 @@
 #include "arrow/status.h"
 
 #include "gandiva/function_holder.h"
+#include "gandiva/json_holder.h"
 #include "gandiva/like_holder.h"
 #include "gandiva/node.h"
 #include "gandiva/random_generator_holder.h"
@@ -64,6 +65,7 @@ class FunctionHolderRegistry {
     static map_type maker_map = {
         {"like", LAMBDA_MAKER(LikeHolder)},
         {"ilike", LAMBDA_MAKER(LikeHolder)},
+        {"get_json_obejct", LAMBDA_MAKER(JsonHolder)},
         {"to_date", LAMBDA_MAKER(ToDateHolder)},
         {"random", LAMBDA_MAKER(RandomGeneratorHolder)},
         {"rand", LAMBDA_MAKER(RandomGeneratorHolder)},

cpp/src/gandiva/function_registry_string.cc

@@ -167,6 +167,10 @@ std::vector<NativeFunction> GetStringFunctionRegistry() {
       NativeFunction("ilike", {}, DataTypeVector{utf8(), utf8()}, boolean(),
                      kResultNullIfNull, "gdv_fn_ilike_utf8_utf8",
                      NativeFunction::kNeedsFunctionHolder),
+                     
+      NativeFunction("get_json_object", {}, DataTypeVector{utf8(), utf8()}, utf8(),
+                     kResultNullIfNull, "gdv_fn_get_json_object_utf8_utf8",
+                     NativeFunction::kNeedsFunctionHolder),
 
       NativeFunction("ltrim", {}, DataTypeVector{utf8(), utf8()}, utf8(),
                      kResultNullIfNull, "ltrim_utf8_utf8", NativeFunction::kNeedsContext),

cpp/src/gandiva/gdv_function_stubs.cc

@@ -27,6 +27,7 @@
 #include "gandiva/formatting_utils.h"
 #include "gandiva/hash_utils.h"
 #include "gandiva/in_holder.h"
+#include "gandiva/json_holder.h"
 #include "gandiva/like_holder.h"
 #include "gandiva/precompiled/types.h"
 #include "gandiva/random_generator_holder.h"
@@ -37,6 +38,12 @@
 
 extern "C" {
 
+const uint8_t* gdv_fn_get_json_object_utf8_utf8(int64_t ptr, const char* data, int data_len,
+                           const char* pattern, int pattern_len, int32_t* out_len) {
+  gandiva::JsonHolder* holder = reinterpret_cast<gandiva::JsonHolder*>(ptr);
+  return (*holder)(std::string(data, data_len), std::string(pattern, pattern_len), out_len);
+}
+
 bool gdv_fn_like_utf8_utf8(int64_t ptr, const char* data, int data_len,
                            const char* pattern, int pattern_len) {
   gandiva::LikeHolder* holder = reinterpret_cast<gandiva::LikeHolder*>(ptr);
@@ -483,6 +490,18 @@ void ExportedStubFunctions::AddMappings(Engine* engine) const {
                                   types->i8_ptr_type() /*return_type*/, args,
                                   reinterpret_cast<void*>(gdv_fn_dec_to_string));
 
+  // gdv_fn_get_json_object_utf8_utf8
+  args = {types->i64_type(),     // int64_t ptr
+          types->i8_ptr_type(),  // const char* data
+          types->i32_type(),     // int data_len
+          types->i8_ptr_type(),  // const char* pattern
+          types->i32_type(),     // int pattern_len
+          types->i32_ptr_type()};   // int out_len 
+
+  engine->AddGlobalMappingForFunc("gdv_fn_get_json_object_utf8_utf8",
+                                  types->i8_ptr_type() /*return_type*/, args,
+                                  reinterpret_cast<void*>(gdv_fn_get_json_object_utf8_utf8));
+
   // gdv_fn_like_utf8_utf8
   args = {types->i64_type(),     // int64_t ptr
           types->i8_ptr_type(),  // const char* data

cpp/src/gandiva/gdv_function_stubs.h

@@ -53,6 +53,9 @@ bool gdv_fn_like_utf8_utf8_utf8(int64_t ptr, const char* data, int data_len,
 
 bool gdv_fn_ilike_utf8_utf8(int64_t ptr, const char* data, int data_len,
                             const char* pattern, int pattern_len);
+                            
+const uint8_t* gdv_fn_get_json_object_utf8_utf8(int64_t ptr, const char* data, int data_len,
+                           const char* pattern, int pattern_len, int32_t* out_len);
 
 int64_t gdv_fn_to_date_utf8_utf8_int32(int64_t context, int64_t ptr, const char* data,
                                        int data_len, bool in1_validity,

cpp/src/gandiva/json_holder.cc

@@ -0,0 +1,59 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "gandiva/json_holder.h"
+
+#include <iostream>
+#include <regex>
+
+#include "gandiva/node.h"
+#include "gandiva/regex_util.h"
+
+namespace gandiva {
+
+Status JsonHolder::Make(const FunctionNode& node, std::shared_ptr<JsonHolder>* holder) {
+  return Make(holder);
+}
+
+Status JsonHolder::Make(std::shared_ptr<JsonHolder>* holder) {
+  *holder = std::shared_ptr<JsonHolder>(new JsonHolder());
+  return Status::OK();
+}
+
+const uint8_t* JsonHolder::operator()(const std::string& json_str, const std::string& json_path, int32_t* out_len) {
+ 
+  std::unique_ptr<arrow::json::BlockParser> parser;
+  (arrow::json::BlockParser::Make(parse_options_, &parser));
+
+  (parser->Parse(std::make_shared<arrow::Buffer>(json_str)));
+  std::shared_ptr<arrow::Array> parsed;
+  (parser->Finish(&parsed));
+  auto struct_parsed = std::dynamic_pointer_cast<arrow::StructArray>(parsed);
+
+  //json_path example: $.col_14, will extract col_14 here
+  // needs to gurad failure here
+  auto col_name = json_path.substr(2);
+
+  auto dict_parsed = std::dynamic_pointer_cast<arrow::DictionaryArray>(
+      struct_parsed->GetFieldByName(col_name));
+  auto dict_array = dict_parsed->dictionary();
+  auto uft8_array = std::dynamic_pointer_cast<arrow::BinaryArray>(dict_array);
+  
+  return uft8_array->GetValue(0, out_len);
+}
+
+}  // namespace gandiva

cpp/src/gandiva/json_holder.h

@@ -0,0 +1,48 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "arrow/json/api.h"
+#include "arrow/json/parser.h"
+#include "arrow/status.h"
+#include "gandiva/function_holder.h"
+#include "gandiva/node.h"
+#include "gandiva/visibility.h"
+
+namespace gandiva {
+
+/// Function Holder for SQL 'get_json_object'
+class GANDIVA_EXPORT JsonHolder : public FunctionHolder {
+ public:
+  JsonHolder() {}
+  ~JsonHolder() override = default;
+
+  static Status Make(const FunctionNode& node, std::shared_ptr<JsonHolder>* holder);
+  static Status Make(std::shared_ptr<JsonHolder>* holder);
+
+  //TODO(): should try to return const uint8_t *
+  const uint8_t* operator()(const std::string& json_str, const std::string& json_path, int32_t* out_len);
+
+  arrow::json::ParseOptions parse_options_ = arrow::json::ParseOptions::Defaults();
+  arrow::json::ReadOptions read_options_ = arrow::json::ReadOptions::Defaults();
+};
+
+}  // namespace gandiva

cpp/src/gandiva/json_holder_test.cc

@@ -0,0 +1,45 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "gandiva/json_holder.h"
+
+#include <gtest/gtest.h>
+
+#include <memory>
+#include <vector>
+
+#include "gandiva/regex_util.h"
+
+namespace gandiva {
+
+class TestJsonHolder : public ::testing::Test {};
+
+TEST_F(TestJsonHolder, TestJson) {
+  std::shared_ptr<JsonHolder> json_holder;
+
+  auto status = JsonHolder::Make(&json_holder);
+  EXPECT_EQ(status.ok(), true) << status.message();
+
+  auto& get_json_object = *json_holder;
+
+  int32_t out_len;
+  const uint8_t* data = get_json_object(R"({"hello": 3.5 })", "$.hello", &out_len);
+  EXPECT_EQ(std::string((char*)data, out_len), "3.5");
+
+}
+
+}  // namespace gandiva