anonymous_namespace{LogicalIR.cpp} Namespace Reference

Functions
bool	contains_unsafe_division (const Analyzer::Expr *expr)
bool	should_defer_eval (const std::shared_ptr< Analyzer::Expr > expr)
Likelihood	get_likelihood (const Analyzer::Expr *expr)
Weight	get_weight (const Analyzer::Expr *expr, int depth=0)
bool	is_qualified_bin_oper (const Analyzer::Expr *expr)

Function Documentation

bool anonymous_namespace{LogicalIR.cpp}::contains_unsafe_division

(

const Analyzer::Expr *

expr

)

Definition at line 25 of file LogicalIR.cpp.

References decimal_to_int_type(), Analyzer::Expr::find_expr(), Analyzer::Constant::get_constval(), Analyzer::BinOper::get_right_operand(), kBIGINT, kBOOLEAN, kDIVIDE, kDOUBLE, kFLOAT, kINT, kSMALLINT, kTINYINT, and run_benchmark_import::type.

Referenced by CodeGenerator::codegenLogicalShortCircuit(), CodeGenerator::prioritizeQuals(), and should_defer_eval().

                                                        {
  auto is_div = [](const Analyzer::Expr* e) -> bool {
    auto bin_oper = dynamic_cast<const Analyzer::BinOper*>(e);
    if (bin_oper && bin_oper->get_optype() == kDIVIDE) {
      auto rhs = bin_oper->get_right_operand();
      auto rhs_constant = dynamic_cast<const Analyzer::Constant*>(rhs);
      if (!rhs_constant || rhs_constant->get_is_null()) {
        return true;
      }
      const auto& datum = rhs_constant->get_constval();
      const auto& ti = rhs_constant->get_type_info();
      const auto type = ti.is_decimal() ? decimal_to_int_type(ti) : ti.get_type();
      if ((type == kBOOLEAN && datum.boolval == 0) ||
          (type == kTINYINT && datum.tinyintval == 0) ||
          (type == kSMALLINT && datum.smallintval == 0) ||
          (type == kINT && datum.intval == 0) ||
          (type == kBIGINT && datum.bigintval == 0LL) ||
          (type == kFLOAT && datum.floatval == 0.0) ||
          (type == kDOUBLE && datum.doubleval == 0.0)) {
        return true;
      }
    }
    return false;
  };
  std::list<const Analyzer::Expr*> binoper_list;
  expr->find_expr(is_div, binoper_list);
  return !binoper_list.empty();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Likelihood anonymous_namespace{LogicalIR.cpp}::get_likelihood

(

const Analyzer::Expr *

expr

)

Definition at line 78 of file LogicalIR.cpp.

References Analyzer::BinOper::get_left_operand(), NullableValue< T >::isInvalid(), kAND, kNOT, and kOR.

Referenced by CodeGenerator::codegenLogicalShortCircuit(), and CodeGenerator::prioritizeQuals().

                                                    {
  Likelihood truth{1.0};
  auto likelihood_expr = dynamic_cast<const Analyzer::LikelihoodExpr*>(expr);
  if (likelihood_expr) {
    return Likelihood(likelihood_expr->get_likelihood());
  }
  auto u_oper = dynamic_cast<const Analyzer::UOper*>(expr);
  if (u_oper) {
    Likelihood oper_likelihood = get_likelihood(u_oper->get_operand());
    if (oper_likelihood.isInvalid()) {
      return Likelihood();
    }
    if (u_oper->get_optype() == kNOT) {
      return truth - oper_likelihood;
    }
    return oper_likelihood;
  }
  auto bin_oper = dynamic_cast<const Analyzer::BinOper*>(expr);
  if (bin_oper) {
    auto lhs = bin_oper->get_left_operand();
    auto rhs = bin_oper->get_right_operand();
    Likelihood lhs_likelihood = get_likelihood(lhs);
    Likelihood rhs_likelihood = get_likelihood(rhs);
    if (lhs_likelihood.isInvalid() && rhs_likelihood.isInvalid()) {
      return Likelihood();
    }
    const auto optype = bin_oper->get_optype();
    if (optype == kOR) {
      auto both_false = (truth - lhs_likelihood) * (truth - rhs_likelihood);
      return truth - both_false;
    }
    if (optype == kAND) {
      return lhs_likelihood * rhs_likelihood;
    }
    return (lhs_likelihood + rhs_likelihood) / 2.0;
  }

  return Likelihood();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Weight anonymous_namespace{LogicalIR.cpp}::get_weight	(	const Analyzer::Expr *	expr,
		int	depth = 0
	)

Definition at line 118 of file LogicalIR.cpp.

References Analyzer::BinOper::get_left_operand().

Referenced by CodeGenerator::codegenLogicalShortCircuit().

                                                           {
  auto like_expr = dynamic_cast<const Analyzer::LikeExpr*>(expr);
  if (like_expr) {
    // heavy weight expr, start valid weight propagation
    return Weight((like_expr->get_is_simple()) ? 200 : 1000);
  }
  auto regexp_expr = dynamic_cast<const Analyzer::RegexpExpr*>(expr);
  if (regexp_expr) {
    // heavy weight expr, start valid weight propagation
    return Weight(2000);
  }
  auto u_oper = dynamic_cast<const Analyzer::UOper*>(expr);
  if (u_oper) {
    auto weight = get_weight(u_oper->get_operand(), depth + 1);
    return weight + 1;
  }
  auto bin_oper = dynamic_cast<const Analyzer::BinOper*>(expr);
  if (bin_oper) {
    auto lhs = bin_oper->get_left_operand();
    auto rhs = bin_oper->get_right_operand();
    auto lhs_weight = get_weight(lhs, depth + 1);
    auto rhs_weight = get_weight(rhs, depth + 1);
    if (rhs->get_type_info().is_array()) {
      // heavy weight expr, start valid weight propagation
      rhs_weight = rhs_weight + Weight(100);
    }
    auto weight = lhs_weight + rhs_weight;
    return weight + 1;
  }

  if (depth > 4) {
    return Weight(1);
  }

  return Weight();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{LogicalIR.cpp}::is_qualified_bin_oper

(

const Analyzer::Expr *

expr

)

Definition at line 355 of file LogicalIR.cpp.

References Analyzer::BinOper::get_qualifier(), and kONE.

Referenced by CodeGenerator::codegenLogical().

                                                     {
  const auto bin_oper = dynamic_cast<const Analyzer::BinOper*>(expr);
  return bin_oper && bin_oper->get_qualifier() != kONE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{LogicalIR.cpp}::should_defer_eval

(

const std::shared_ptr< Analyzer::Expr >

expr

)

Definition at line 54 of file LogicalIR.cpp.

References contains_unsafe_division(), Analyzer::BinOper::get_right_operand(), Analyzer::Expr::get_type_info(), and SQLTypeInfo::is_array().

Referenced by CodeGenerator::prioritizeQuals().

                                                               {
  if (std::dynamic_pointer_cast<Analyzer::LikeExpr>(expr)) {
    return true;
  }
  if (std::dynamic_pointer_cast<Analyzer::RegexpExpr>(expr)) {
    return true;
  }
  if (std::dynamic_pointer_cast<Analyzer::FunctionOper>(expr)) {
    return true;
  }
  if (!std::dynamic_pointer_cast<Analyzer::BinOper>(expr)) {
    return false;
  }
  const auto bin_expr = std::static_pointer_cast<Analyzer::BinOper>(expr);
  if (contains_unsafe_division(bin_expr.get())) {
    return true;
  }
  if (bin_expr->is_bbox_intersect_oper()) {
    return false;
  }
  const auto rhs = bin_expr->get_right_operand();
  return rhs->get_type_info().is_array();
}

Here is the call graph for this function:

Here is the caller graph for this function: