anonymous_namespace{EquiJoinCondition.cpp} Namespace Reference

Functions
bool	can_combine_with (const Analyzer::Expr *crt, const Analyzer::Expr *prev)
std::list< std::shared_ptr < Analyzer::Expr > >	make_composite_equals_impl (const std::vector< std::shared_ptr< Analyzer::Expr >> &crt_coalesced_quals)
std::list< std::shared_ptr < Analyzer::Expr > >	make_composite_equals (const std::vector< std::shared_ptr< Analyzer::Expr >> &crt_coalesced_quals)

Function Documentation

bool anonymous_namespace{EquiJoinCondition.cpp}::can_combine_with	(	const Analyzer::Expr *	crt,
		const Analyzer::Expr *	prev
	)

Definition at line 26 of file EquiJoinCondition.cpp.

References IS_EQUIVALENCE, kONE, remove_cast(), and ScalarExprVisitor< T >::visit().

Referenced by combine_equi_join_conditions().

                                                                         {
  const auto crt_bin = dynamic_cast<const Analyzer::BinOper*>(crt);
  const auto prev_bin = dynamic_cast<const Analyzer::BinOper*>(prev);
  if (!crt_bin || !prev_bin) {
    return false;
  }
  if (!IS_EQUIVALENCE(crt_bin->get_optype()) || crt_bin->get_qualifier() != kONE ||
      !IS_EQUIVALENCE(prev_bin->get_optype()) || prev_bin->get_qualifier() != kONE ||
      // We could accept a mix of kEQ and kBW_EQ, but don't bother for now.
      crt_bin->get_optype() != prev_bin->get_optype()) {
    return false;
  }

  auto get_rhs_col_var = [](const auto bin_oper) {
    auto inner_col_var = std::dynamic_pointer_cast<Analyzer::ColumnVar>(
        remove_cast(bin_oper->get_own_right_operand()));
    if (!inner_col_var) {
      const auto string_oper = std::dynamic_pointer_cast<Analyzer::StringOper>(
          remove_cast(bin_oper->get_own_right_operand()));
      if (string_oper && string_oper->getArity() >= 1UL) {
        inner_col_var =
            std::dynamic_pointer_cast<Analyzer::ColumnVar>(string_oper->getOwnArg(0));
      }
    }
    return inner_col_var;
  };

  const std::shared_ptr<Analyzer::ColumnVar> crt_inner_col_var = get_rhs_col_var(crt_bin);
  const std::shared_ptr<Analyzer::ColumnVar> prev_inner_col_var =
      get_rhs_col_var(prev_bin);
  if (!crt_inner_col_var || !prev_inner_col_var) {
    return false;
  }
  AllRangeTableIndexVisitor visitor;
  const auto crt_outer_rte_set = visitor.visit(crt_bin->get_left_operand());
  const auto prev_outer_rte_set = visitor.visit(prev_bin->get_left_operand());
  // We shouldn't treat mixed nesting levels columns as a composite key tuple.
  if (crt_outer_rte_set.size() != 1 || prev_outer_rte_set.size() != 1 ||
      crt_outer_rte_set != prev_outer_rte_set) {
    return false;
  }
  if (crt_inner_col_var->getTableKey() != prev_inner_col_var->getTableKey() ||
      crt_inner_col_var->get_rte_idx() != prev_inner_col_var->get_rte_idx()) {
    return false;
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::list<std::shared_ptr<Analyzer::Expr> > anonymous_namespace{EquiJoinCondition.cpp}::make_composite_equals

(

const std::vector< std::shared_ptr< Analyzer::Expr >> &

crt_coalesced_quals

)

Definition at line 119 of file EquiJoinCondition.cpp.

References make_composite_equals_impl().

Referenced by combine_equi_join_conditions().

                                                                       {
  if (crt_coalesced_quals.size() == 1) {
    return {crt_coalesced_quals.front()};
  }
  return make_composite_equals_impl(crt_coalesced_quals);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::list<std::shared_ptr<Analyzer::Expr> > anonymous_namespace{EquiJoinCondition.cpp}::make_composite_equals_impl

(

const std::vector< std::shared_ptr< Analyzer::Expr >> &

crt_coalesced_quals

)

Definition at line 74 of file EquiJoinCondition.cpp.

References CHECK, CHECK_EQ, IS_NUMBER, IS_STRING, kBOOLEAN, kENCODING_DICT, kONE, and remove_cast().

Referenced by coalesce_singleton_equi_join(), and make_composite_equals().

                                                                       {
  std::list<std::shared_ptr<Analyzer::Expr>> join_quals;
  std::vector<std::shared_ptr<Analyzer::Expr>> lhs_tuple;
  std::vector<std::shared_ptr<Analyzer::Expr>> rhs_tuple;
  bool not_null{true};
  for (const auto& qual : crt_coalesced_quals) {
    const auto qual_binary = std::dynamic_pointer_cast<Analyzer::BinOper>(qual);
    CHECK(qual_binary);
    not_null = not_null && qual_binary->get_type_info().get_notnull();
    const auto lhs_col = remove_cast(qual_binary->get_own_left_operand());
    const auto rhs_col = remove_cast(qual_binary->get_own_right_operand());
    const auto lhs_ti = lhs_col->get_type_info();
    // Coalesce cols for integers, bool, and dict encoded strings. Forces baseline hash
    // join.
    if (IS_NUMBER(lhs_ti.get_type()) ||
        (IS_STRING(lhs_ti.get_type()) && lhs_ti.get_compression() == kENCODING_DICT) ||
        (lhs_ti.get_type() == kBOOLEAN)) {
      lhs_tuple.push_back(lhs_col);
      rhs_tuple.push_back(rhs_col);
    } else {
      join_quals.push_back(qual);
    }
  }
  CHECK(!crt_coalesced_quals.empty());
  const auto first_qual =
      std::dynamic_pointer_cast<Analyzer::BinOper>(crt_coalesced_quals.front());
  CHECK(first_qual);
  CHECK_EQ(lhs_tuple.size(), rhs_tuple.size());
  if (lhs_tuple.size() > 0) {
    join_quals.push_front(std::make_shared<Analyzer::BinOper>(
        SQLTypeInfo(kBOOLEAN, not_null),
        false,
        first_qual->get_optype(),
        kONE,
        lhs_tuple.size() > 1 ? std::make_shared<Analyzer::ExpressionTuple>(lhs_tuple)
                             : lhs_tuple.front(),
        rhs_tuple.size() > 1 ? std::make_shared<Analyzer::ExpressionTuple>(rhs_tuple)
                             : rhs_tuple.front()));
  }
  return join_quals;
}

Here is the call graph for this function:

Here is the caller graph for this function: