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)

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 292 of file ParserNode.h.

Constructor & Destructor Documentation

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

inline

Definition at line 294 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 296 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 244 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 299 of file ParserNode.h.

References left.

{ return left.get(); }

SQLOps Parser::OperExpr::get_optype ( ) const

inline

Definition at line 298 of file ParserNode.h.

References optype.

{ return optype; }

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

inline

Definition at line 300 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  )

static

Definition at line 270 of file ParserNode.cpp.

References Analyzer::BinOper::analyze_type_info(), CHECK, SQLTypeInfo::get_array_type(), SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), IS_COMPARISON, SQLTypeInfo::is_geometry(), kARRAY, kENCODING_DICT, kENCODING_NONE, kONE, kOVERLAPS, SQLTypeInfo::set_comp_param(), SQLTypeInfo::set_compression(), and SQLTypeInfo::set_fixed_size().

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 &&
        new_left_type.get_comp_param() == new_right_type.get_comp_param()) {
      // do nothing
    } 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.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.set_fixed_size();
      left_expr = left_expr->add_cast(ti);
    } else {
      left_expr = left_expr->decompress();
      right_expr = right_expr->decompress();
    }
  } else {
    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 1285 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 315 of file ParserNode.h.

Referenced by get_left().

SQLQualifier Parser::OperExpr::opqualifier

private

Definition at line 314 of file ParserNode.h.

SQLOps Parser::OperExpr::optype

private

Definition at line 313 of file ParserNode.h.

Referenced by get_optype().

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

private

Definition at line 316 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