Parser::LikeExpr Class Reference

#include <ParserNode.h>

Inheritance diagram for Parser::LikeExpr:

Collaboration diagram for Parser::LikeExpr:

Public Member Functions
	LikeExpr (bool n, bool i, Expr *a, Expr *l, Expr *e)
bool	get_is_not () const
const Expr *	get_arg () const
const Expr *	get_like_string () const
const Expr *	get_escape_string () const
std::shared_ptr< Analyzer::Expr >	analyze (const Catalog_Namespace::Catalog &catalog, Analyzer::Query &query, TlistRefType allow_tlist_ref=TLIST_NONE) const override
std::string	to_string () const override
Public Member Functions inherited from Parser::Node
virtual	~Node ()

Static Public Member Functions
static std::shared_ptr < Analyzer::Expr >	get (std::shared_ptr< Analyzer::Expr > arg_expr, std::shared_ptr< Analyzer::Expr > like_expr, std::shared_ptr< Analyzer::Expr > escape_expr, const bool is_ilike, const bool is_not)

Static Private Member Functions
static void	check_like_expr (const std::string &like_str, char escape_char)
static bool	test_is_simple_expr (const std::string &like_str, char escape_char)
static void	erase_cntl_chars (std::string &like_str, char escape_char)

Private Attributes
bool	is_not_
bool	is_ilike_
std::unique_ptr< Expr >	arg_
std::unique_ptr< Expr >	like_string_
std::unique_ptr< Expr >	escape_string_

Additional Inherited Members
Public Types inherited from Parser::Expr
enum	TlistRefType { TLIST_NONE, TLIST_REF, TLIST_COPY }

Detailed Description

Definition at line 492 of file ParserNode.h.

Constructor & Destructor Documentation

Parser::LikeExpr::LikeExpr ( bool  n, bool  i, Expr *  a, Expr *  l, Expr *  e  )

inline

Definition at line 494 of file ParserNode.h.

      : is_not_(n), is_ilike_(i), arg_(a), like_string_(l), escape_string_(e) {}

Member Function Documentation

std::shared_ptr< Analyzer::Expr > Parser::LikeExpr::analyze ( const Catalog_Namespace::Catalog &  catalog, Analyzer::Query &  query, TlistRefType  allow_tlist_ref = TLIST_NONE  ) const

overridevirtual

Implements Parser::Expr.

Definition at line 688 of file ParserNode.cpp.

                                        {
  auto arg_expr = arg_->analyze(catalog, query, allow_tlist_ref);
  auto like_expr = like_string_->analyze(catalog, query, allow_tlist_ref);
  auto escape_expr = escape_string_ == nullptr
                         ? nullptr
                         : escape_string_->analyze(catalog, query, allow_tlist_ref);
  return LikeExpr::get(arg_expr, like_expr, escape_expr, is_ilike_, is_not_);
}

void Parser::LikeExpr::check_like_expr ( const std::string &  like_str, char  escape_char  )

staticprivate

Definition at line 642 of file ParserNode.cpp.

                                                                          {
  if (like_str.back() == escape_char) {
    throw std::runtime_error("LIKE pattern must not end with escape character.");
  }
}

void Parser::LikeExpr::erase_cntl_chars ( std::string &  like_str, char  escape_char  )

staticprivate

Definition at line 669 of file ParserNode.cpp.

                                                                     {
  char prev_char = '\0';
  // easier to create new string of allowable chars
  // rather than erase chars from
  // existing string
  std::string new_str;
  for (char& cur_char : like_str) {
    if (cur_char == '%' || cur_char == escape_char) {
      if (prev_char != escape_char) {
        prev_char = cur_char;
        continue;
      }
    }
    new_str.push_back(cur_char);
    prev_char = cur_char;
  }
  like_str = new_str;
}

std::shared_ptr< Analyzer::Expr > Parser::LikeExpr::get ( std::shared_ptr< Analyzer::Expr >  arg_expr, std::shared_ptr< Analyzer::Expr >  like_expr, std::shared_ptr< Analyzer::Expr >  escape_expr, const bool  is_ilike, const bool  is_not  )

static

Definition at line 700 of file ParserNode.cpp.

References Analyzer::Constant::get_constval(), kBOOLEAN, kNOT, run_benchmark_import::result, Datum::stringval, and shared::transform().

Referenced by RelAlgTranslator::translateLike().

                                                                 {
  if (!arg_expr->get_type_info().is_string()) {
    throw std::runtime_error("expression before LIKE must be of a string type.");
  }
  if (!like_expr->get_type_info().is_string()) {
    throw std::runtime_error("expression after LIKE must be of a string type.");
  }
  char escape_char = '\\';
  if (escape_expr != nullptr) {
    if (!escape_expr->get_type_info().is_string()) {
      throw std::runtime_error("expression after ESCAPE must be of a string type.");
    }
    if (!escape_expr->get_type_info().is_string()) {
      throw std::runtime_error("expression after ESCAPE must be of a string type.");
    }
    auto c = std::dynamic_pointer_cast<Analyzer::Constant>(escape_expr);
    if (c != nullptr && c->get_constval().stringval->length() > 1) {
      throw std::runtime_error("String after ESCAPE must have a single character.");
    }
    escape_char = (*c->get_constval().stringval)[0];
  }
  auto c = std::dynamic_pointer_cast<Analyzer::Constant>(like_expr);
  bool is_simple = false;
  if (c != nullptr) {
    std::string& pattern = *c->get_constval().stringval;
    if (is_ilike) {
      std::transform(pattern.begin(), pattern.end(), pattern.begin(), ::tolower);
    }
    check_like_expr(pattern, escape_char);
    is_simple = test_is_simple_expr(pattern, escape_char);
    if (is_simple) {
      erase_cntl_chars(pattern, escape_char);
    }
  }
  std::shared_ptr<Analyzer::Expr> result = makeExpr<Analyzer::LikeExpr>(
      arg_expr->decompress(), like_expr, escape_expr, is_ilike, is_simple);
  if (is_not) {
    result = makeExpr<Analyzer::UOper>(kBOOLEAN, kNOT, result);
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const Expr* Parser::LikeExpr::get_arg ( ) const

inline

Definition at line 497 of file ParserNode.h.

References arg_.

{ return arg_.get(); }

const Expr* Parser::LikeExpr::get_escape_string ( ) const

inline

Definition at line 499 of file ParserNode.h.

References escape_string_.

{ return escape_string_.get(); }

bool Parser::LikeExpr::get_is_not ( ) const

inline

Definition at line 496 of file ParserNode.h.

References is_not_.

{ return is_not_; }

const Expr* Parser::LikeExpr::get_like_string ( ) const

inline

Definition at line 498 of file ParserNode.h.

References like_string_.

{ return like_string_.get(); }

bool Parser::LikeExpr::test_is_simple_expr ( const std::string &  like_str, char  escape_char  )

staticprivate

Definition at line 648 of file ParserNode.cpp.

                                                                              {
  // if not bounded by '%' then not a simple string
  if (like_str.size() < 2 || like_str[0] != '%' || like_str[like_str.size() - 1] != '%') {
    return false;
  }
  // if the last '%' is escaped then not a simple string
  if (like_str[like_str.size() - 2] == escape_char &&
      like_str[like_str.size() - 3] != escape_char) {
    return false;
  }
  for (size_t i = 1; i < like_str.size() - 1; i++) {
    if (like_str[i] == '%' || like_str[i] == '_' || like_str[i] == '[' ||
        like_str[i] == ']') {
      if (like_str[i - 1] != escape_char) {
        return false;
      }
    }
  }
  return true;
}

std::string Parser::LikeExpr::to_string ( ) const

overridevirtual

Implements Parser::Expr.

Definition at line 2244 of file ParserNode.cpp.

                                    {
  std::string str = arg_->to_string();
  if (is_not_) {
    str += " NOT LIKE ";
  } else {
    str += " LIKE ";
  }
  str += like_string_->to_string();
  if (escape_string_ != nullptr) {
    str += " ESCAPE " + escape_string_->to_string();
  }
  return str;
}

Member Data Documentation

std::unique_ptr<Expr> Parser::LikeExpr::arg_

private

Definition at line 514 of file ParserNode.h.

Referenced by get_arg().

std::unique_ptr<Expr> Parser::LikeExpr::escape_string_

private

Definition at line 516 of file ParserNode.h.

Referenced by get_escape_string().

bool Parser::LikeExpr::is_ilike_

private

Definition at line 513 of file ParserNode.h.

bool Parser::LikeExpr::is_not_

private

Definition at line 512 of file ParserNode.h.

Referenced by get_is_not().

std::unique_ptr<Expr> Parser::LikeExpr::like_string_

private

Definition at line 515 of file ParserNode.h.

Referenced by get_like_string().

---

The documentation for this class was generated from the following files:

• /home/jenkins-slave/workspace/core-os-doxygen/Parser/ParserNode.h
• /home/jenkins-slave/workspace/core-os-doxygen/Parser/ParserNode.cpp