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)

Function Documentation

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.

                                          {
  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();
  }
}

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.

                                                          {
  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();
  }
}

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.

                                                          {
  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();
  }
}

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.

                                               {
  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();
  }
}