Parser::OperExpr Class Reference

#include <ParserNode.h>

Inheritance diagram for Parser::OperExpr:

Collaboration diagram for Parser::OperExpr:

Public Member Functions
	OperExpr (SQLOps t, Expr *l, Expr *r)
	OperExpr (SQLOps t, SQLQualifier q, Expr *l, Expr *r)
SQLOps	get_optype () const
const Expr *	get_left () const
const Expr *	get_right () 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 >	normalize (const SQLOps optype, const SQLQualifier qual, std::shared_ptr< Analyzer::Expr > left_expr, std::shared_ptr< Analyzer::Expr > right_expr, const Executor *executor=nullptr)

Private Attributes
SQLOps	optype_
SQLQualifier	opqualifier_
std::unique_ptr< Expr >	left_
std::unique_ptr< Expr >	right_

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

Detailed Description

Definition at line 296 of file ParserNode.h.

Constructor & Destructor Documentation

Parser::OperExpr::OperExpr ( SQLOps  t, Expr *  l, Expr *  r  )

inline

Definition at line 298 of file ParserNode.h.

      : optype_(t), opqualifier_(kONE), left_(l), right_(r) {}

Parser::OperExpr::OperExpr ( SQLOps  t, SQLQualifier  q, Expr *  l, Expr *  r  )

inline

Definition at line 300 of file ParserNode.h.

      : optype_(t), opqualifier_(q), left_(l), right_(r) {}

Member Function Documentation

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

overridevirtual

Implements Parser::Expr.

Definition at line 287 of file ParserNode.cpp.

References kARRAY, kARRAY_AT, and kONE.

                                        {
  auto left_expr = left_->analyze(catalog, query, allow_tlist_ref);
  const auto& left_type = left_expr->get_type_info();
  if (right_ == nullptr) {
    return makeExpr<Analyzer::UOper>(
        left_type, left_expr->get_contains_agg(), optype_, left_expr->decompress());
  }
  if (optype_ == kARRAY_AT) {
    if (left_type.get_type() != kARRAY) {
      throw std::runtime_error(left_->to_string() + " is not of array type.");
    }
    auto right_expr = right_->analyze(catalog, query, allow_tlist_ref);
    const auto& right_type = right_expr->get_type_info();
    if (!right_type.is_integer()) {
      throw std::runtime_error(right_->to_string() + " is not of integer type.");
    }
    return makeExpr<Analyzer::BinOper>(
        left_type.get_elem_type(), false, kARRAY_AT, kONE, left_expr, right_expr);
  }
  auto right_expr = right_->analyze(catalog, query, allow_tlist_ref);
  return normalize(optype_, opqualifier_, left_expr, right_expr);
}

const Expr* Parser::OperExpr::get_left ( ) const

inline

Definition at line 303 of file ParserNode.h.

References left_.

{ return left_.get(); }

SQLOps Parser::OperExpr::get_optype ( ) const

inline

Definition at line 302 of file ParserNode.h.

References optype_.

{ return optype_; }

const Expr* Parser::OperExpr::get_right ( ) const

inline

Definition at line 304 of file ParserNode.h.

References right_.

{ return right_.get(); }

std::shared_ptr< Analyzer::Expr > Parser::OperExpr::normalize ( const SQLOps  optype, const SQLQualifier  qual, std::shared_ptr< Analyzer::Expr >  left_expr, std::shared_ptr< Analyzer::Expr >  right_expr, const Executor *  executor = nullptr  )

static

Definition at line 372 of file ParserNode.cpp.

References Analyzer::BinOper::analyze_type_info(), CHECK, Parser::exprs_share_one_and_same_rte_idx(), SQLTypeInfo::get_array_type(), SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), Parser::get_str_dict_cast_type(), SQLTypeInfo::getStringDictKey(), IS_COMPARISON, SQLTypeInfo::is_geometry(), kARRAY, kENCODING_DICT, kENCODING_NONE, kEQ, kNE, kONE, kOVERLAPS, SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), SQLTypeInfo::set_dict_intersection(), SQLTypeInfo::set_fixed_size(), and SQLTypeInfo::setStringDictKey().

Referenced by anonymous_namespace{RelAlgExecutor.cpp}::build_logical_expression(), anonymous_namespace{CompareIR.cpp}::lower_bw_eq(), anonymous_namespace{CompareIR.cpp}::make_eq(), anonymous_namespace{RelAlgExecutor.cpp}::reverse_logical_distribution(), RelAlgTranslator::translateFunction(), and RelAlgTranslator::translateOper().

                              {
  if (left_expr->get_type_info().is_date_in_days() ||
      right_expr->get_type_info().is_date_in_days()) {
    // Do not propogate encoding
    left_expr = left_expr->decompress();
    right_expr = right_expr->decompress();
  }
  const auto& left_type = left_expr->get_type_info();
  auto right_type = right_expr->get_type_info();
  if (qual != kONE) {
    // subquery not supported yet.
    CHECK(!std::dynamic_pointer_cast<Analyzer::Subquery>(right_expr));
    if (right_type.get_type() != kARRAY) {
      throw std::runtime_error(
          "Existential or universal qualifiers can only be used in front of a subquery "
          "or an "
          "expression of array type.");
    }
    right_type = right_type.get_elem_type();
  }
  SQLTypeInfo new_left_type;
  SQLTypeInfo new_right_type;
  auto result_type = Analyzer::BinOper::analyze_type_info(
      optype, left_type, right_type, &new_left_type, &new_right_type);
  if (result_type.is_timeinterval()) {
    return makeExpr<Analyzer::BinOper>(
        result_type, false, optype, qual, left_expr, right_expr);
  }
  if (left_type != new_left_type) {
    left_expr = left_expr->add_cast(new_left_type);
  }
  if (right_type != new_right_type) {
    if (qual == kONE) {
      right_expr = right_expr->add_cast(new_right_type);
    } else {
      right_expr = right_expr->add_cast(new_right_type.get_array_type());
    }
  }

  if (IS_COMPARISON(optype)) {
    if (optype != kOVERLAPS && new_left_type.is_geometry() &&
        new_right_type.is_geometry()) {
      throw std::runtime_error(
          "Comparison operators are not yet supported for geospatial types.");
    }

    if (new_left_type.get_compression() == kENCODING_DICT &&
        new_right_type.get_compression() == kENCODING_DICT) {
      if (new_left_type.getStringDictKey() != new_right_type.getStringDictKey()) {
        if (optype == kEQ || optype == kNE) {
          // Join framework does its own string dictionary translation
          // (at least partly since the rhs table projection does not use
          // the normal runtime execution framework), so if we detect
          // that the rte idxs of the two tables are different, bail
          // on translating
          const bool should_translate_strings =
              exprs_share_one_and_same_rte_idx(left_expr, right_expr);
          if (should_translate_strings && (optype == kEQ || optype == kNE)) {
            CHECK(executor);
            // Make the type we're casting to the transient dictionary, if it exists,
            // otherwise the largest dictionary in terms of number of entries
            SQLTypeInfo ti(
                get_str_dict_cast_type(new_left_type, new_right_type, executor));
            auto& expr_to_cast = ti == new_left_type ? right_expr : left_expr;
            ti.set_fixed_size();
            ti.set_dict_intersection();
            expr_to_cast = expr_to_cast->add_cast(ti);
          } else {  // Ordered comparison operator
            // We do not currently support ordered (i.e. >, <=) comparisons between
            // dictionary-encoded columns, and need to decompress when translation
            // is turned off even for kEQ and KNE
            left_expr = left_expr->decompress();
            right_expr = right_expr->decompress();
          }
        } else {  // Ordered comparison operator
          // We do not currently support ordered (i.e. >, <=) comparisons between
          // dictionary-encoded columns, and need to decompress when translation
          // is turned off even for kEQ and KNE
          left_expr = left_expr->decompress();
          right_expr = right_expr->decompress();
        }
      } else {  // Strings shared comp param
        if (!(optype == kEQ || optype == kNE)) {
          // We do not currently support ordered (i.e. >, <=) comparisons between
          // encoded columns, so try to decode (will only succeed with watchdog off)
          left_expr = left_expr->decompress();
          right_expr = right_expr->decompress();
        } else {
          // do nothing, can directly support equals/non-equals comparisons between two
          // dictionary encoded columns sharing the same dictionary as these are
          // effectively integer comparisons in the same dictionary space
        }
      }
    } else if (new_left_type.get_compression() == kENCODING_DICT &&
               new_right_type.get_compression() == kENCODING_NONE) {
      SQLTypeInfo ti(new_right_type);
      ti.set_compression(new_left_type.get_compression());
      ti.set_comp_param(new_left_type.get_comp_param());
      ti.setStringDictKey(new_left_type.getStringDictKey());
      ti.set_fixed_size();
      right_expr = right_expr->add_cast(ti);
    } else if (new_right_type.get_compression() == kENCODING_DICT &&
               new_left_type.get_compression() == kENCODING_NONE) {
      SQLTypeInfo ti(new_left_type);
      ti.set_compression(new_right_type.get_compression());
      ti.set_comp_param(new_right_type.get_comp_param());
      ti.setStringDictKey(new_right_type.getStringDictKey());
      ti.set_fixed_size();
      left_expr = left_expr->add_cast(ti);
    } else {
      left_expr = left_expr->decompress();
      right_expr = right_expr->decompress();
    }
  } else {
    // Is this now a no-op just for pairs of none-encoded string columns
    left_expr = left_expr->decompress();
    right_expr = right_expr->decompress();
  }
  bool has_agg = (left_expr->get_contains_agg() || right_expr->get_contains_agg());
  return makeExpr<Analyzer::BinOper>(
      result_type, has_agg, optype, qual, left_expr, right_expr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Implements Parser::Expr.

Definition at line 2123 of file ParserNode.cpp.

References kARRAY_AT, kIN, kNOT, kUMINUS, and kUNNEST.

                                    {
  std::string op_str[] = {
      "=", "===", "<>", "<", ">", "<=", ">=", " AND ", " OR ", "NOT", "-", "+", "*", "/"};
  std::string str;
  if (optype_ == kUMINUS) {
    str = "-(" + left_->to_string() + ")";
  } else if (optype_ == kNOT) {
    str = "NOT (" + left_->to_string() + ")";
  } else if (optype_ == kARRAY_AT) {
    str = left_->to_string() + "[" + right_->to_string() + "]";
  } else if (optype_ == kUNNEST) {
    str = "UNNEST(" + left_->to_string() + ")";
  } else if (optype_ == kIN) {
    str = "(" + left_->to_string() + " IN " + right_->to_string() + ")";
  } else {
    str = "(" + left_->to_string() + op_str[optype_] + right_->to_string() + ")";
  }
  return str;
}

Member Data Documentation

std::unique_ptr<Expr> Parser::OperExpr::left_

private

Definition at line 320 of file ParserNode.h.

Referenced by get_left().

SQLQualifier Parser::OperExpr::opqualifier_

private

Definition at line 319 of file ParserNode.h.

SQLOps Parser::OperExpr::optype_

private

Definition at line 318 of file ParserNode.h.

Referenced by get_optype().

std::unique_ptr<Expr> Parser::OperExpr::right_

private

Definition at line 321 of file ParserNode.h.

Referenced by get_right().

---

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