Method TryOptimize

cpp/src/gandiva/regex_functions_holder.cc:37–88

Short-circuit pattern matches for the following common sub cases : - starts_with, ends_with and is_substr

// Short-circuit pattern matches for the following common sub cases :
// - starts_with, ends_with and is_substr
const FunctionNode LikeHolder::TryOptimize(const FunctionNode& node) {
  // NOTE: avoid making those constants global to avoid compiling regexes at startup
  // pre-compiled pattern for matching starts_with
  static const RE2 starts_with_regex(R"(([^\.\*])*\.\*)");
  // pre-compiled pattern for matching ends_with
  static const RE2 ends_with_regex(R"(\.\*([^\.\*])*)");
  // pre-compiled pattern for matching is_substr
  static const RE2 is_substr_regex(R"(\.\*([^\.\*])*\.\*)");

  static bool global_checked = false;
  if (ARROW_PREDICT_FALSE(!global_checked)) {
    if (ARROW_PREDICT_FALSE(
            !(starts_with_regex.ok() && ends_with_regex.ok() && is_substr_regex.ok()))) {
      return node;
    }
    global_checked = true;
  }

  auto maybe_holder = Make(node);
  if (maybe_holder.ok()) {
    auto holder = *maybe_holder;
    std::string& pattern = holder->pattern_;
    auto literal_type = node.children().at(1)->return_type();

    if (RE2::FullMatch(pattern, starts_with_regex)) {
      auto prefix = pattern.substr(0, pattern.length() - 2);  // trim .*
      auto parsed_prefix = RemovePatternEscapeChars(node, prefix);
      auto prefix_node = std::make_shared<LiteralNode>(
          literal_type, LiteralHolder(parsed_prefix), false);
      return FunctionNode("starts_with", {node.children().at(0), prefix_node},
                          node.return_type());
    } else if (RE2::FullMatch(pattern, ends_with_regex)) {
      auto suffix = pattern.substr(2);  // skip .*
      auto parsed_suffix = RemovePatternEscapeChars(node, suffix);
      auto suffix_node = std::make_shared<LiteralNode>(
          literal_type, LiteralHolder(parsed_suffix), false);
      return FunctionNode("ends_with", {node.children().at(0), suffix_node},
                          node.return_type());
    } else if (RE2::FullMatch(pattern, is_substr_regex)) {
      auto substr =
          pattern.substr(2, pattern.length() - 4);  // trim starting and ending .*
      auto parsed_substr = RemovePatternEscapeChars(node, substr);
      auto substr_node = std::make_shared<LiteralNode>(
          literal_type, LiteralHolder(parsed_substr), false);
      return FunctionNode("is_substr", {node.children().at(0), substr_node},
                          node.return_type());
    }
  }

  // Could not optimize, return original node.
  return node;
}

Result<std::shared_ptr<LikeHolder>> LikeHolder::Make(const FunctionNode& node) {
  ARROW_RETURN_IF(node.children().size() != 2 && node.children().size() != 3,