anonymous_namespace{CompareIR.cpp} Namespace Reference

Functions
llvm::CmpInst::Predicate	llvm_icmp_pred (const SQLOps op_type)
std::string	icmp_name (const SQLOps op_type)
std::string	icmp_arr_name (const SQLOps op_type)
llvm::CmpInst::Predicate	llvm_fcmp_pred (const SQLOps op_type)
std::string	string_cmp_func (const SQLOps optype)
std::shared_ptr < Analyzer::BinOper >	lower_bw_eq (const Analyzer::BinOper *bw_eq)
std::shared_ptr < Analyzer::BinOper >	make_eq (const std::shared_ptr< Analyzer::Expr > &lhs, const std::shared_ptr< Analyzer::Expr > &rhs, const SQLOps optype)
std::shared_ptr < Analyzer::BinOper >	lower_multicol_compare (const Analyzer::BinOper *multicol_compare)
void	check_array_comp_cond (const Analyzer::BinOper *bin_oper)

Function Documentation

void anonymous_namespace{CompareIR.cpp}::check_array_comp_cond

(

const Analyzer::BinOper *

bin_oper

)

Definition at line 182 of file CompareIR.cpp.

References Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_optype(), Analyzer::BinOper::get_right_operand(), IS_COMPARISON, IS_EQUIVALENCE, kARRAY_AT, kNE, and kTEXT.

Referenced by CodeGenerator::codegenCmp().

                                                            {
  auto lhs_cv = dynamic_cast<const Analyzer::ColumnVar*>(bin_oper->get_left_operand());
  auto rhs_cv = dynamic_cast<const Analyzer::ColumnVar*>(bin_oper->get_right_operand());
  auto comp_op = IS_COMPARISON(bin_oper->get_optype());
  if (lhs_cv && rhs_cv && comp_op) {
    auto lhs_ti = lhs_cv->get_type_info();
    auto rhs_ti = rhs_cv->get_type_info();
    if (lhs_ti.is_array() && rhs_ti.is_array()) {
      throw std::runtime_error(
          "Comparing two full array columns is not supported yet. Please consider "
          "rewriting the full array comparison to a comparison between indexed array "
          "columns "
          "(i.e., arr1[1] {<, <=, >, >=} arr2[1]).");
    }
  }
  auto lhs_bin_oper =
      dynamic_cast<const Analyzer::BinOper*>(bin_oper->get_left_operand());
  auto rhs_bin_oper =
      dynamic_cast<const Analyzer::BinOper*>(bin_oper->get_right_operand());
  // we can do (non-)equivalence check of two encoded string
  // even if they are (indexed) array cols
  auto theta_comp = IS_COMPARISON(bin_oper->get_optype()) &&
                    !IS_EQUIVALENCE(bin_oper->get_optype()) &&
                    bin_oper->get_optype() != SQLOps::kNE;
  if (lhs_bin_oper && rhs_bin_oper && theta_comp &&
      lhs_bin_oper->get_optype() == SQLOps::kARRAY_AT &&
      rhs_bin_oper->get_optype() == SQLOps::kARRAY_AT) {
    auto lhs_arr_cv =
        dynamic_cast<const Analyzer::ColumnVar*>(lhs_bin_oper->get_left_operand());
    auto lhs_arr_idx =
        dynamic_cast<const Analyzer::Constant*>(lhs_bin_oper->get_right_operand());
    auto rhs_arr_cv =
        dynamic_cast<const Analyzer::ColumnVar*>(rhs_bin_oper->get_left_operand());
    auto rhs_arr_idx =
        dynamic_cast<const Analyzer::Constant*>(rhs_bin_oper->get_right_operand());
    if (lhs_arr_cv && rhs_arr_cv && lhs_arr_idx && rhs_arr_idx &&
        ((lhs_arr_cv->get_type_info().is_array() &&
          lhs_arr_cv->get_type_info().get_subtype() == SQLTypes::kTEXT) ||
         (rhs_arr_cv->get_type_info().is_string() &&
          rhs_arr_cv->get_type_info().get_subtype() == SQLTypes::kTEXT))) {
      throw std::runtime_error(
          "Comparison between string array columns is not supported yet.");
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string anonymous_namespace{CompareIR.cpp}::icmp_arr_name

(

const SQLOps

op_type

)

Definition at line 64 of file CompareIR.cpp.

References kEQ, kGE, kGT, kLE, kLT, and kNE.

Referenced by CodeGenerator::codegenQualifierCmp().

                                              {
  switch (op_type) {
    case kEQ:
      return "eq";
    case kNE:
      return "ne";
    case kLT:
      return "gt";
    case kGT:
      return "lt";
    case kLE:
      return "ge";
    case kGE:
      return "le";
    default:
      abort();
  }
}

Here is the caller graph for this function:

std::string anonymous_namespace{CompareIR.cpp}::icmp_name

(

const SQLOps

op_type

)

Definition at line 45 of file CompareIR.cpp.

References kEQ, kGE, kGT, kLE, kLT, and kNE.

Referenced by CodeGenerator::codegenCmp().

                                          {
  switch (op_type) {
    case kEQ:
      return "eq";
    case kNE:
      return "ne";
    case kLT:
      return "lt";
    case kGT:
      return "gt";
    case kLE:
      return "le";
    case kGE:
      return "ge";
    default:
      abort();
  }
}

Here is the caller graph for this function:

llvm::CmpInst::Predicate anonymous_namespace{CompareIR.cpp}::llvm_fcmp_pred

(

const SQLOps

op_type

)

Definition at line 83 of file CompareIR.cpp.

References kEQ, kGE, kGT, kLE, kLT, and kNE.

Referenced by CodeGenerator::codegenCmp().

                                                          {
  switch (op_type) {
    case kEQ:
      return llvm::CmpInst::FCMP_OEQ;
    case kNE:
      return llvm::CmpInst::FCMP_ONE;
    case kLT:
      return llvm::CmpInst::FCMP_OLT;
    case kGT:
      return llvm::CmpInst::FCMP_OGT;
    case kLE:
      return llvm::CmpInst::FCMP_OLE;
    case kGE:
      return llvm::CmpInst::FCMP_OGE;
    default:
      abort();
  }
}

Here is the caller graph for this function:

llvm::CmpInst::Predicate anonymous_namespace{CompareIR.cpp}::llvm_icmp_pred

(

const SQLOps

op_type

)

Definition at line 26 of file CompareIR.cpp.

References kEQ, kGE, kGT, kLE, kLT, and kNE.

Referenced by CodeGenerator::codegenCmp().

                                                          {
  switch (op_type) {
    case kEQ:
      return llvm::ICmpInst::ICMP_EQ;
    case kNE:
      return llvm::ICmpInst::ICMP_NE;
    case kLT:
      return llvm::ICmpInst::ICMP_SLT;
    case kGT:
      return llvm::ICmpInst::ICMP_SGT;
    case kLE:
      return llvm::ICmpInst::ICMP_SLE;
    case kGE:
      return llvm::ICmpInst::ICMP_SGE;
    default:
      abort();
  }
}

Here is the caller graph for this function:

std::shared_ptr<Analyzer::BinOper> anonymous_namespace{CompareIR.cpp}::lower_bw_eq

(

const Analyzer::BinOper *

bw_eq

)

Definition at line 125 of file CompareIR.cpp.

References CHECK, Analyzer::Expr::get_contains_agg(), Analyzer::BinOper::get_own_left_operand(), Analyzer::BinOper::get_own_right_operand(), Analyzer::BinOper::get_qualifier(), Analyzer::Expr::get_type_info(), kAND, kBOOLEAN, kEQ, kISNULL, kONE, kOR, and Parser::OperExpr::normalize().

Referenced by CodeGenerator::codegenCmp(), and make_eq().

                                                                         {
  const auto eq_oper =
      std::make_shared<Analyzer::BinOper>(bw_eq->get_type_info(),
                                          bw_eq->get_contains_agg(),
                                          kEQ,
                                          bw_eq->get_qualifier(),
                                          bw_eq->get_own_left_operand(),
                                          bw_eq->get_own_right_operand());
  const auto lhs_is_null =
      std::make_shared<Analyzer::UOper>(kBOOLEAN, kISNULL, bw_eq->get_own_left_operand());
  const auto rhs_is_null = std::make_shared<Analyzer::UOper>(
      kBOOLEAN, kISNULL, bw_eq->get_own_right_operand());
  const auto both_are_null =
      Parser::OperExpr::normalize(kAND, kONE, lhs_is_null, rhs_is_null);
  const auto bw_eq_oper = std::dynamic_pointer_cast<Analyzer::BinOper>(
      Parser::OperExpr::normalize(kOR, kONE, eq_oper, both_are_null));
  CHECK(bw_eq_oper);
  return bw_eq_oper;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<Analyzer::BinOper> anonymous_namespace{CompareIR.cpp}::lower_multicol_compare

(

const Analyzer::BinOper *

multicol_compare

)

Definition at line 159 of file CompareIR.cpp.

References CHECK, CHECK_EQ, CHECK_GT, Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_optype(), Analyzer::BinOper::get_right_operand(), kAND, kBOOLEAN, kONE, and make_eq().

Referenced by CodeGenerator::codegenCmp().

                                             {
  const auto left_tuple_expr = dynamic_cast<const Analyzer::ExpressionTuple*>(
      multicol_compare->get_left_operand());
  const auto right_tuple_expr = dynamic_cast<const Analyzer::ExpressionTuple*>(
      multicol_compare->get_right_operand());
  CHECK(left_tuple_expr && right_tuple_expr);
  const auto& left_tuple = left_tuple_expr->getTuple();
  const auto& right_tuple = right_tuple_expr->getTuple();
  CHECK_EQ(left_tuple.size(), right_tuple.size());
  CHECK_GT(left_tuple.size(), size_t(1));
  auto acc =
      make_eq(left_tuple.front(), right_tuple.front(), multicol_compare->get_optype());
  for (size_t i = 1; i < left_tuple.size(); ++i) {
    auto crt = make_eq(left_tuple[i], right_tuple[i], multicol_compare->get_optype());
    const bool not_null =
        acc->get_type_info().get_notnull() && crt->get_type_info().get_notnull();
    acc = makeExpr<Analyzer::BinOper>(
        SQLTypeInfo(kBOOLEAN, not_null), false, kAND, kONE, acc, crt);
  }
  return acc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr<Analyzer::BinOper> anonymous_namespace{CompareIR.cpp}::make_eq	(	const std::shared_ptr< Analyzer::Expr > &	lhs,
		const std::shared_ptr< Analyzer::Expr > &	rhs,
		const SQLOps	optype
	)

Definition at line 145 of file CompareIR.cpp.

References CHECK, IS_EQUIVALENCE, kBW_EQ, kONE, lower_bw_eq(), and Parser::OperExpr::normalize().

Referenced by lower_multicol_compare().

                                                                {
  CHECK(IS_EQUIVALENCE(optype));
  // Sides of a tuple equality are stripped of cast operators to simplify the logic
  // in the hash table construction algorithm. Add them back here.
  auto eq_oper = std::dynamic_pointer_cast<Analyzer::BinOper>(
      Parser::OperExpr::normalize(optype, kONE, lhs, rhs));
  CHECK(eq_oper);
  return optype == kBW_EQ ? lower_bw_eq(eq_oper.get()) : eq_oper;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string anonymous_namespace{CompareIR.cpp}::string_cmp_func

(

const SQLOps

optype

)

Definition at line 106 of file CompareIR.cpp.

References kEQ, kGE, kGT, kLE, kLT, and kNE.

Referenced by CodeGenerator::codegenCmp().

                                               {
  switch (optype) {
    case kLT:
      return "string_lt";
    case kLE:
      return "string_le";
    case kGT:
      return "string_gt";
    case kGE:
      return "string_ge";
    case kEQ:
      return "string_eq";
    case kNE:
      return "string_ne";
    default:
      abort();
  }
}

Here is the caller graph for this function: