GDV-56: [C++] Add support for sql regex functions (apache#86)

- add a registry for "function holders" implemented in cpp
- the function holder is instantiated at expression decomposition time
- at eval time, the registered fn gets an extra param (the . function holder)

cpp/src/gandiva/codegen/CMakeLists.txt

@@ -35,8 +35,10 @@ set(SRC_FILES annotator.cc
  function_signature.cc
  llvm_generator.cc
  llvm_types.cc
+ like_holder.cc
  projector.cc
  selection_vector.cc
+ regex_util.cc
  status.cc
  tree_expr_builder.cc
  ${BC_FILE_PATH_CC})
@@ -84,17 +86,16 @@ install(
 
 #args: label test-file src-files
 add_gandiva_unit_test(bitmap_accumulator_test.cc bitmap_accumulator.cc)
-add_gandiva_unit_test(dex_llvm_test.cc)
 add_gandiva_unit_test(engine_llvm_test.cc engine.cc llvm_types.cc status.cc configuration.cc ${BC_FILE_PATH_CC})
 add_gandiva_unit_test(function_signature_test.cc function_signature.cc)
 add_gandiva_unit_test(function_registry_test.cc function_registry.cc function_signature.cc)
 add_gandiva_unit_test(llvm_types_test.cc llvm_types.cc)
-add_gandiva_unit_test(llvm_generator_test.cc llvm_generator.cc engine.cc llvm_types.cc expr_decomposer.cc function_registry.cc annotator.cc status.cc bitmap_accumulator.cc configuration.cc function_signature.cc ${BC_FILE_PATH_CC})
+add_gandiva_unit_test(llvm_generator_test.cc llvm_generator.cc regex_util.cc engine.cc llvm_types.cc expr_decomposer.cc function_registry.cc annotator.cc status.cc bitmap_accumulator.cc configuration.cc function_signature.cc like_holder.cc regex_util.cc ${BC_FILE_PATH_CC})
 add_gandiva_unit_test(annotator_test.cc annotator.cc function_signature.cc)
-add_gandiva_unit_test(tree_expr_test.cc tree_expr_builder.cc expr_decomposer.cc annotator.cc function_registry.cc function_signature.cc)
-add_gandiva_unit_test(expr_decomposer_test.cc expr_decomposer.cc tree_expr_builder.cc annotator.cc function_registry.cc function_signature.cc)
+add_gandiva_unit_test(tree_expr_test.cc tree_expr_builder.cc expr_decomposer.cc annotator.cc function_registry.cc function_signature.cc like_holder.cc regex_util.cc status.cc)
+add_gandiva_unit_test(expr_decomposer_test.cc expr_decomposer.cc tree_expr_builder.cc annotator.cc function_registry.cc function_signature.cc like_holder.cc regex_util.cc status.cc)
 add_gandiva_unit_test(status_test.cc status.cc)
 add_gandiva_unit_test(expression_registry_test.cc llvm_types.cc expression_registry.cc function_signature.cc function_registry.cc)
 add_gandiva_unit_test(selection_vector_test.cc selection_vector.cc status.cc)
 add_gandiva_unit_test(lru_cache_test.cc)
-
+add_gandiva_unit_test(like_holder_test.cc like_holder.cc regex_util.cc status.cc)

cpp/src/gandiva/codegen/dex.h

@@ -21,6 +21,7 @@
 #include "codegen/dex_visitor.h"
 #include "codegen/field_descriptor.h"
 #include "codegen/func_descriptor.h"
+#include "codegen/function_holder.h"
 #include "codegen/literal_holder.h"
 #include "codegen/native_function.h"
 #include "codegen/value_validity_pair.h"
@@ -104,20 +105,24 @@ class LocalBitMapValidityDex : public Dex {
 class FuncDex : public Dex {
  public:
  FuncDex(FuncDescriptorPtr func_descriptor, const NativeFunction *native_function,
- const ValueValidityPairVector &args)
+ FunctionHolderPtr function_holder, const ValueValidityPairVector &args)
  : func_descriptor_(func_descriptor),
  native_function_(native_function),
+ function_holder_(function_holder),
  args_(args) {}
 
  FuncDescriptorPtr func_descriptor() const { return func_descriptor_; }
 
  const NativeFunction *native_function() const { return native_function_; }
 
+ FunctionHolderPtr function_holder() const { return function_holder_; }
+
  const ValueValidityPairVector &args() const { return args_; }
 
  private:
  FuncDescriptorPtr func_descriptor_;
  const NativeFunction *native_function_;
+ FunctionHolderPtr function_holder_;
  ValueValidityPairVector args_;
 };
 
@@ -127,8 +132,9 @@ class NonNullableFuncDex : public FuncDex {
  public:
  NonNullableFuncDex(FuncDescriptorPtr func_descriptor,
  const NativeFunction *native_function,
+ FunctionHolderPtr function_holder,
  const ValueValidityPairVector &args)
- : FuncDex(func_descriptor, native_function, args) {}
+ : FuncDex(func_descriptor, native_function, function_holder, args) {}
 
  void Accept(DexVisitor &visitor) override { visitor.Visit(*this); }
 };
@@ -139,8 +145,9 @@ class NullableNeverFuncDex : public FuncDex {
  public:
  NullableNeverFuncDex(FuncDescriptorPtr func_descriptor,
  const NativeFunction *native_function,
+ FunctionHolderPtr function_holder,
  const ValueValidityPairVector &args)
- : FuncDex(func_descriptor, native_function, args) {}
+ : FuncDex(func_descriptor, native_function, function_holder, args) {}
 
  void Accept(DexVisitor &visitor) override { visitor.Visit(*this); }
 };
@@ -151,8 +158,9 @@ class NullableInternalFuncDex : public FuncDex {
  public:
  NullableInternalFuncDex(FuncDescriptorPtr func_descriptor,
  const NativeFunction *native_function,
+ FunctionHolderPtr function_holder,
  const ValueValidityPairVector &args, int local_bitmap_idx)
- : FuncDex(func_descriptor, native_function, args),
+ : FuncDex(func_descriptor, native_function, function_holder, args),
  local_bitmap_idx_(local_bitmap_idx) {}
 
  void Accept(DexVisitor &visitor) override { visitor.Visit(*this); }

cpp/src/gandiva/codegen/expr_decomposer.cc

@@ -21,6 +21,7 @@
 
 #include "codegen/annotator.h"
 #include "codegen/dex.h"
+#include "codegen/function_holder_registry.h"
 #include "codegen/function_registry.h"
 #include "codegen/node.h"
 #include "gandiva/function_signature.h"
@@ -53,10 +54,19 @@ Status ExprDecomposer::Visit(const FunctionNode &node) {
  // decompose the children.
  std::vector<ValueValidityPairPtr> args;
  for (auto &child : node.children()) {
- child->Accept(*this);
+ auto status = child->Accept(*this);
+ GANDIVA_RETURN_NOT_OK(status);
+
  args.push_back(result());
  }
 
+ // Make a function holder, if required.
+ std::shared_ptr<FunctionHolder> holder;
+ if (native_function->needs_holder()) {
+ auto status = FunctionHolderRegistry::Make(desc->name(), node, &holder);
+ GANDIVA_RETURN_NOT_OK(status);
+ }
+
  if (native_function->result_nullable_type() == RESULT_NULL_IF_NULL) {
  // These functions are decomposable, merge the validity bits of the children.
 
@@ -68,11 +78,13 @@ Status ExprDecomposer::Visit(const FunctionNode &node) {
  decomposed->validity_exprs().end());
  }
 
- auto value_dex = std::make_shared<NonNullableFuncDex>(desc, native_function, args);
+ auto value_dex =
+ std::make_shared<NonNullableFuncDex>(desc, native_function, holder, args);
  result_ = std::make_shared<ValueValidityPair>(merged_validity, value_dex);
  } else if (native_function->result_nullable_type() == RESULT_NULL_NEVER) {
  // These functions always output valid results. So, no validity dex.
- auto value_dex = std::make_shared<NullableNeverFuncDex>(desc, native_function, args);
+ auto value_dex =
+ std::make_shared<NullableNeverFuncDex>(desc, native_function, holder, args);
  result_ = std::make_shared<ValueValidityPair>(value_dex);
  } else {
  DCHECK(native_function->result_nullable_type() == RESULT_NULL_INTERNAL);
@@ -81,8 +93,8 @@ Status ExprDecomposer::Visit(const FunctionNode &node) {
  int local_bitmap_idx = annotator_.AddLocalBitMap();
  auto validity_dex = std::make_shared<LocalBitMapValidityDex>(local_bitmap_idx);
 
- auto value_dex = std::make_shared<NullableInternalFuncDex>(desc, native_function,
-   args, local_bitmap_idx);
+ auto value_dex = std::make_shared<NullableInternalFuncDex>(
+ desc, native_function, holder, args, local_bitmap_idx);
  result_ = std::make_shared<ValueValidityPair>(validity_dex, value_dex);
  }
  return Status::OK();
@@ -91,16 +103,19 @@ Status ExprDecomposer::Visit(const FunctionNode &node) {
 // Decompose an IfNode
 Status ExprDecomposer::Visit(const IfNode &node) {
  // Add a local bitmap to track the output validity.
- node.condition()->Accept(*this);
+ auto status = node.condition()->Accept(*this);
+ GANDIVA_RETURN_NOT_OK(status);
  auto condition_vv = result();
 
  int local_bitmap_idx = PushThenEntry(node);
- node.then_node()->Accept(*this);
+ status = node.then_node()->Accept(*this);
+ GANDIVA_RETURN_NOT_OK(status);
  auto then_vv = result();
  PopThenEntry(node);
 
  PushElseEntry(node, local_bitmap_idx);
- node.else_node()->Accept(*this);
+ status = node.else_node()->Accept(*this);
+ GANDIVA_RETURN_NOT_OK(status);
  auto else_vv = result();
  bool is_terminal_else = PopElseEntry(node);
 
@@ -118,7 +133,9 @@ Status ExprDecomposer::Visit(const BooleanNode &node) {
  // decompose the children.
  std::vector<ValueValidityPairPtr> args;
  for (auto &child : node.children()) {
- child->Accept(*this);
+ auto status = child->Accept(*this);
+ GANDIVA_RETURN_NOT_OK(status);
+
  args.push_back(result());
  }
 

cpp/src/gandiva/codegen/expr_decomposer.h

@@ -36,9 +36,12 @@ class ExprDecomposer : public NodeVisitor {
  explicit ExprDecomposer(const FunctionRegistry &registry, Annotator &annotator)
  : registry_(registry), annotator_(annotator) {}
 
- ValueValidityPairPtr Decompose(const Node &root) {
- root.Accept(*this);
- return result();
+ Status Decompose(const Node &root, ValueValidityPairPtr *out) {
+ auto status = root.Accept(*this);
+ if (status.ok()) {
+ *out = std::move(result_);
+ }
+ return status;
  }
 
  private:

cpp/src/gandiva/codegen/expression_registry.cc

@@ -29,27 +29,26 @@ ExpressionRegistry::~ExpressionRegistry() {}
 
 const ExpressionRegistry::FunctionSignatureIterator
 ExpressionRegistry::function_signature_begin() {
- return FunctionSignatureIterator(function_registry_->begin(),
- function_registry_->end());
+ return FunctionSignatureIterator(function_registry_->begin());
 }
 
 const ExpressionRegistry::FunctionSignatureIterator
 ExpressionRegistry::function_signature_end() const {
- return FunctionSignatureIterator(function_registry_->end(), function_registry_->end());
+ return FunctionSignatureIterator(function_registry_->end());
 }
 
 bool ExpressionRegistry::FunctionSignatureIterator::operator!=(
  const FunctionSignatureIterator &func_sign_it) {
- return func_sign_it.it != this->it;
+ return func_sign_it.it_ != this->it_;
 }
 
 FunctionSignature ExpressionRegistry::FunctionSignatureIterator::operator*() {
- return (*it).signature();
+ return (*it_).signature();
 }
 
 ExpressionRegistry::iterator ExpressionRegistry::FunctionSignatureIterator::operator++(
  int increment) {
- return it++;
+ return it_++;
 }
 
 DataTypeVector ExpressionRegistry::supported_types_ =