anonymous_namespace{PerfectJoinHashTable.cpp} Namespace Reference

Functions
std::pair< InnerOuter, InnerOuterStringOpInfos >	get_cols (const Analyzer::BinOper *qual_bin_oper, const TemporaryTables *temporary_tables)
BucketizedHashEntryInfo	get_bucketized_hash_entry_info (SQLTypeInfo const &context_ti, ExpressionRange const &col_range, bool const is_bw_eq)
size_t	get_hash_entry_count (const ExpressionRange &col_range, const bool is_bw_eq)
bool	shard_count_less_or_equal_device_count (const shared::TableKey &inner_table_key, const Executor *executor)

Function Documentation

BucketizedHashEntryInfo anonymous_namespace{PerfectJoinHashTable.cpp}::get_bucketized_hash_entry_info	(	SQLTypeInfo const &	context_ti,
		ExpressionRange const &	col_range,
		bool const	is_bw_eq
	)

Definition at line 49 of file PerfectJoinHashTable.cpp.

References CHECK_EQ, CHECK_GT, SQLTypeInfo::get_type(), ExpressionRange::getBucket(), ExpressionRange::getIntMax(), ExpressionRange::getIntMin(), and kDATE.

Referenced by PerfectJoinHashTable::getInstance(), PerfectJoinHashTable::isOneToOneHashPossible(), and PerfectJoinHashTable::reify().

                                                                            {
  using EmptyRangeSize = boost::optional<size_t>;
  auto empty_range_check = [](ExpressionRange const& col_range,
                              bool const is_bw_eq) -> EmptyRangeSize {
    if (col_range.getIntMin() > col_range.getIntMax()) {
      CHECK_EQ(col_range.getIntMin(), int64_t(0));
      CHECK_EQ(col_range.getIntMax(), int64_t(-1));
      if (is_bw_eq) {
        return size_t(1);
      }
      return size_t(0);
    }
    return EmptyRangeSize{};
  };

  auto empty_range = empty_range_check(col_range, is_bw_eq);
  if (empty_range) {
    return {size_t(*empty_range), 1};
  }

  int64_t bucket_normalization =
      context_ti.get_type() == kDATE ? col_range.getBucket() : 1;
  CHECK_GT(bucket_normalization, 0);
  auto const normalized_max = col_range.getIntMax() / bucket_normalization;
  auto const normalized_min = col_range.getIntMin() / bucket_normalization;
  return {size_t(normalized_max - normalized_min + 1 + (is_bw_eq ? 1 : 0)),
          bucket_normalization};
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair<InnerOuter, InnerOuterStringOpInfos> anonymous_namespace{PerfectJoinHashTable.cpp}::get_cols	(	const Analyzer::BinOper *	qual_bin_oper,
		const TemporaryTables *	temporary_tables
	)

Definition at line 41 of file PerfectJoinHashTable.cpp.

References Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_right_operand(), and HashJoin::normalizeColumnPair().

                                             {
  const auto lhs = qual_bin_oper->get_left_operand();
  const auto rhs = qual_bin_oper->get_right_operand();
  return HashJoin::normalizeColumnPair(lhs, rhs, temporary_tables);
}

Here is the call graph for this function:

size_t anonymous_namespace{PerfectJoinHashTable.cpp}::get_hash_entry_count	(	const ExpressionRange &	col_range,
		const bool	is_bw_eq
	)

Definition at line 80 of file PerfectJoinHashTable.cpp.

References CHECK_EQ, ExpressionRange::getIntMax(), and ExpressionRange::getIntMin().

Referenced by PerfectJoinHashTable::getHashJoinArgs().

                                                                                   {
  if (col_range.getIntMin() > col_range.getIntMax()) {
    CHECK_EQ(col_range.getIntMin(), int64_t(0));
    CHECK_EQ(col_range.getIntMax(), int64_t(-1));
    return is_bw_eq ? 1 : 0;
  }
  return col_range.getIntMax() - col_range.getIntMin() + 1 + (is_bw_eq ? 1 : 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool anonymous_namespace{PerfectJoinHashTable.cpp}::shard_count_less_or_equal_device_count	(	const shared::TableKey &	inner_table_key,
		const Executor *	executor
	)

Definition at line 93 of file PerfectJoinHashTable.cpp.

Referenced by get_shard_count().

                                                                      {
  const auto inner_table_info = executor->getTableInfo(inner_table_key);
  std::unordered_set<int> device_holding_fragments;
  auto cuda_mgr = executor->getDataMgr()->getCudaMgr();
  const int device_count = cuda_mgr ? cuda_mgr->getDeviceCount() : 1;
  for (const auto& fragment : inner_table_info.fragments) {
    if (fragment.shard != -1) {
      const auto it_ok = device_holding_fragments.emplace(fragment.shard % device_count);
      if (!it_ok.second) {
        return false;
      }
    }
  }
  return true;
}

Here is the caller graph for this function: