#include <HashJoin.h>

Inheritance diagram for HashJoin:

Public Member Functions
virtual std::string	toString (const ExecutorDeviceType device_type, const int device_id=0, bool raw=false) const =0

virtual std::string	toStringFlat64 (const ExecutorDeviceType device_type, const int device_id) const

virtual std::string	toStringFlat32 (const ExecutorDeviceType device_type, const int device_id) const

virtual DecodedJoinHashBufferSet	toSet (const ExecutorDeviceType device_type, const int device_id) const =0

virtual llvm::Value *	codegenSlot (const CompilationOptions &, const size_t)=0

virtual HashJoinMatchingSet	codegenMatchingSet (const CompilationOptions &, const size_t)=0

virtual shared::TableKey	getInnerTableId () const noexcept=0

virtual int	getInnerTableRteIdx () const noexcept=0

virtual HashType	getHashType () const noexcept=0

virtual Data_Namespace::MemoryLevel	getMemoryLevel () const noexcept=0

virtual int	getDeviceCount () const noexcept=0

virtual size_t	offsetBufferOff () const noexcept=0

virtual size_t	countBufferOff () const noexcept=0

virtual size_t	payloadBufferOff () const noexcept=0

virtual std::string	getHashJoinType () const =0

virtual bool	isBitwiseEq () const =0

JoinColumn	fetchJoinColumn (const Analyzer::ColumnVar hash_col, const std::vector< Fragmenter_Namespace::FragmentInfo > &fragment_info, const Data_Namespace::MemoryLevel effective_memory_level, const int device_id, std::vector< std::shared_ptr< Chunk_NS::Chunk >> &chunks_owner, DeviceAllocator dev_buff_owner, std::vector< std::shared_ptr< void >> &malloc_owner, Executor executor, ColumnCacheMap column_cache)

HashTable *	getHashTableForDevice (const size_t device_id) const

size_t	getJoinHashBufferSize (const ExecutorDeviceType device_type)

size_t	getJoinHashBufferSize (const ExecutorDeviceType device_type, const int device_id) const

int8_t *	getJoinHashBuffer (const ExecutorDeviceType device_type, const int device_id) const

void	freeHashBufferMemory ()

Static Public Member Functions
static bool	layoutRequiresAdditionalBuffers (HashType layout) noexcept

static std::string	getHashTypeString (HashType ht) noexcept

static HashJoinMatchingSet	codegenMatchingSet (const std::vector< llvm::Value * > &hash_join_idx_args_in, const bool is_sharded, const bool col_is_nullable, const bool is_bw_eq, const int64_t sub_buff_size, Executor *executor, const bool is_bucketized=false)

static llvm::Value *	codegenHashTableLoad (const size_t table_idx, Executor *executor)

static std::shared_ptr< HashJoin >	getInstance (const std::shared_ptr< Analyzer::BinOper > qual_bin_oper, const std::vector< InputTableInfo > &query_infos, const Data_Namespace::MemoryLevel memory_level, const JoinType join_type, const HashType preferred_hash_type, const int device_count, ColumnCacheMap &column_cache, Executor *executor, const HashTableBuildDagMap &hashtable_build_dag_map, const RegisteredQueryHint &query_hint, const TableIdToNodeMap &table_id_to_node_map)
	Make hash table from an in-flight SQL query's parse tree etc. More...

static std::shared_ptr< HashJoin >	getSyntheticInstance (std::string_view table1, std::string_view column1, const Catalog_Namespace::Catalog &catalog1, std::string_view table2, std::string_view column2, const Catalog_Namespace::Catalog &catalog2, const Data_Namespace::MemoryLevel memory_level, const HashType preferred_hash_type, const int device_count, ColumnCacheMap &column_cache, Executor *executor)
	Make hash table from named tables and columns (such as for testing). More...

static std::shared_ptr< HashJoin >	getSyntheticInstance (const std::shared_ptr< Analyzer::BinOper > qual_bin_oper, const Data_Namespace::MemoryLevel memory_level, const HashType preferred_hash_type, const int device_count, ColumnCacheMap &column_cache, Executor *executor)
	Make hash table from named tables and columns (such as for testing). More...

static std::pair< std::string, std::shared_ptr< HashJoin > >	getSyntheticInstance (std::vector< std::shared_ptr< Analyzer::BinOper >>, const Data_Namespace::MemoryLevel memory_level, const HashType preferred_hash_type, const int device_count, ColumnCacheMap &column_cache, Executor *executor)

static shared::TableKey	getInnerTableId (const std::vector< InnerOuter > &inner_outer_pairs)

static bool	canAccessHashTable (bool allow_hash_table_recycling, bool invalid_cache_key, JoinType join_type)

static void	checkHashJoinReplicationConstraint (const shared::TableKey &table_key, const size_t shard_count, const Executor *executor)

static std::pair< InnerOuter, InnerOuterStringOpInfos >	normalizeColumnPair (const Analyzer::Expr lhs, const Analyzer::Expr rhs, const TemporaryTables *temporary_tables, const bool is_overlaps_join=false)

template<typename T >
static const T *	getHashJoinColumn (const Analyzer::Expr *expr)

static std::pair< std::vector < InnerOuter >, std::vector < InnerOuterStringOpInfos > >	normalizeColumnPairs (const Analyzer::BinOper condition, const TemporaryTables temporary_tables)

static std::vector< int >	collectFragmentIds (const std::vector< Fragmenter_Namespace::FragmentInfo > &fragments)

static CompositeKeyInfo	getCompositeKeyInfo (const std::vector< InnerOuter > &inner_outer_pairs, const Executor *executor, const std::vector< InnerOuterStringOpInfos > &inner_outer_string_op_infos_pairs={})

static std::vector< const StringDictionaryProxy::IdMap * >	translateCompositeStrDictProxies (const CompositeKeyInfo &composite_key_info, const std::vector< InnerOuterStringOpInfos > &string_op_infos_for_keys, const Executor *executor)

static std::pair< const StringDictionaryProxy , StringDictionaryProxy >	getStrDictProxies (const InnerOuter &cols, const Executor *executor, const bool has_string_ops)

static const StringDictionaryProxy::IdMap *	translateInnerToOuterStrDictProxies (const InnerOuter &cols, const InnerOuterStringOpInfos &inner_outer_string_op_infos, ExpressionRange &old_col_range, const Executor *executor)

Protected Member Functions
virtual size_t	getComponentBufferSize () const noexcept=0

Static Protected Member Functions
static llvm::Value *	codegenColOrStringOper (const Analyzer::Expr *col_or_string_oper, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos, CodeGenerator &code_generator, const CompilationOptions &co)

Protected Attributes
std::vector< std::shared_ptr < HashTable > >	hash_tables_for_device_

Detailed Description

Definition at line 135 of file HashJoin.h.

Member Function Documentation

bool HashJoin::canAccessHashTable	(	bool	allow_hash_table_recycling,
		bool	invalid_cache_key,
		JoinType	join_type
	)

static

Definition at line 1030 of file HashJoin.cpp.

References g_enable_data_recycler, g_use_hashtable_cache, and INVALID.

Referenced by PerfectJoinHashTable::reify(), and BaselineJoinHashTable::reifyWithLayout().

                                                       {
   return g_enable_data_recycler && g_use_hashtable_cache && !invalid_cache_key &&
          allow_hash_table_recycling && join_type != JoinType::INVALID;
 }

Here is the caller graph for this function:

void HashJoin::checkHashJoinReplicationConstraint	(	const shared::TableKey &	table_key,
		const size_t	shard_count,
		const Executor *	executor
	)

static

Definition at line 779 of file HashJoin.cpp.

References CHECK, g_cluster, Catalog_Namespace::get_metadata_for_table(), shared::TableKey::table_id, and table_is_replicated().

Referenced by RangeJoinHashTable::getInstance(), BaselineJoinHashTable::reify(), and PerfectJoinHashTable::reify().

                                                                             {
   if (!g_cluster) {
     return;
   }
   if (table_key.table_id >= 0) {
     CHECK(executor);
     const auto inner_td = Catalog_Namespace::get_metadata_for_table(table_key);
     CHECK(inner_td);
     if (!shard_count && !table_is_replicated(inner_td)) {
       throw TableMustBeReplicated(inner_td->tableName);
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * HashJoin::codegenColOrStringOper	(	const Analyzer::Expr *	col_or_string_oper,
		const std::vector< StringOps_Namespace::StringOpInfo > &	string_op_infos,
		CodeGenerator &	code_generator,
		const CompilationOptions &	co
	)

staticprotected

Definition at line 545 of file HashJoin.cpp.

References CHECK, CodeGenerator::codegen(), and CodeGenerator::codegenPseudoStringOper().

Referenced by BaselineJoinHashTable::codegenKey(), PerfectJoinHashTable::codegenMatchingSet(), and PerfectJoinHashTable::codegenSlot().

                                   {
   if (!string_op_infos.empty()) {
     const auto coerced_col_var =
         dynamic_cast<const Analyzer::ColumnVar*>(col_or_string_oper);
     CHECK(coerced_col_var);
     std::vector<llvm::Value*> codegen_val_vec{
         code_generator.codegenPseudoStringOper(coerced_col_var, string_op_infos, co)};
     return codegen_val_vec[0];
   }
   return code_generator.codegen(col_or_string_oper, true, co)[0];
 }

Here is the call graph for this function:

Here is the caller graph for this function:

llvm::Value * HashJoin::codegenHashTableLoad	(	const size_t	table_idx,
		Executor *	executor
	)

static

Definition at line 257 of file HashJoin.cpp.

References AUTOMATIC_IR_METADATA, CHECK, CHECK_LT, and get_arg_by_name().

Referenced by PerfectJoinHashTable::codegenHashTableLoad(), BaselineJoinHashTable::codegenMatchingSet(), OverlapsJoinHashTable::codegenMatchingSet(), RangeJoinHashTable::codegenMatchingSetWithOffset(), and BaselineJoinHashTable::hashPtr().

                                                                                     {
   AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
   llvm::Value* hash_ptr = nullptr;
   const auto total_table_count =
       executor->plan_state_->join_info_.join_hash_tables_.size();
   CHECK_LT(table_idx, total_table_count);
   if (total_table_count > 1) {
     auto hash_tables_ptr =
         get_arg_by_name(executor->cgen_state_->row_func_, "join_hash_tables");
     auto hash_pptr =
         table_idx > 0
             ? executor->cgen_state_->ir_builder_.CreateGEP(
                   hash_tables_ptr->getType()->getScalarType()->getPointerElementType(),
                   hash_tables_ptr,
                   executor->cgen_state_->llInt(static_cast<int64_t>(table_idx)))
             : hash_tables_ptr;
     hash_ptr = executor->cgen_state_->ir_builder_.CreateLoad(
         hash_pptr->getType()->getPointerElementType(), hash_pptr);
   } else {
     hash_ptr = get_arg_by_name(executor->cgen_state_->row_func_, "join_hash_tables");
   }
   CHECK(hash_ptr);
   return hash_ptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual HashJoinMatchingSet HashJoin::codegenMatchingSet	(	const CompilationOptions &	,
		const size_t
	)

pure virtual

Implemented in OverlapsJoinHashTable, BaselineJoinHashTable, and PerfectJoinHashTable.

Referenced by PerfectJoinHashTable::codegenMatchingSet(), BaselineJoinHashTable::codegenMatchingSet(), OverlapsJoinHashTable::codegenMatchingSet(), and RangeJoinHashTable::codegenMatchingSetWithOffset().

Here is the caller graph for this function:

HashJoinMatchingSet HashJoin::codegenMatchingSet	(	const std::vector< llvm::Value * > &	hash_join_idx_args_in,
		const bool	is_sharded,
		const bool	col_is_nullable,
		const bool	is_bw_eq,
		const int64_t	sub_buff_size,
		Executor *	executor,
		const bool	is_bucketized = `false`
	)

static

Definition at line 206 of file HashJoin.cpp.

References AUTOMATIC_IR_METADATA, and CHECK.

                         {
   AUTOMATIC_IR_METADATA(executor->cgen_state_.get());
   using namespace std::string_literals;
 
   std::string fname(is_bucketized ? "bucketized_hash_join_idx"s : "hash_join_idx"s);
 
   if (is_bw_eq) {
     fname += "_bitwise";
   }
   if (is_sharded) {
     fname += "_sharded";
   }
   if (!is_bw_eq && col_is_nullable) {
     fname += "_nullable";
   }
 
   const auto slot_lv = executor->cgen_state_->emitCall(fname, hash_join_idx_args_in);
   const auto slot_valid_lv = executor->cgen_state_->ir_builder_.CreateICmpSGE(
       slot_lv, executor->cgen_state_->llInt(int64_t(0)));
 
   auto pos_ptr = hash_join_idx_args_in[0];
   CHECK(pos_ptr);
 
   auto count_ptr = executor->cgen_state_->ir_builder_.CreateAdd(
       pos_ptr, executor->cgen_state_->llInt(sub_buff_size));
   auto hash_join_idx_args = hash_join_idx_args_in;
   hash_join_idx_args[0] = executor->cgen_state_->ir_builder_.CreatePtrToInt(
       count_ptr, llvm::Type::getInt64Ty(executor->cgen_state_->context_));
 
   const auto row_count_lv = executor->cgen_state_->ir_builder_.CreateSelect(
       slot_valid_lv,
       executor->cgen_state_->emitCall(fname, hash_join_idx_args),
       executor->cgen_state_->llInt(int64_t(0)));
   auto rowid_base_i32 = executor->cgen_state_->ir_builder_.CreateIntToPtr(
       executor->cgen_state_->ir_builder_.CreateAdd(
           pos_ptr, executor->cgen_state_->llInt(2 * sub_buff_size)),
       llvm::Type::getInt32PtrTy(executor->cgen_state_->context_));
   auto rowid_ptr_i32 = executor->cgen_state_->ir_builder_.CreateGEP(
       rowid_base_i32->getType()->getScalarType()->getPointerElementType(),
       rowid_base_i32,
       slot_lv);
   return {rowid_ptr_i32, row_count_lv, slot_lv};
 }

virtual llvm::Value* HashJoin::codegenSlot	(	const CompilationOptions &	,
		const size_t
	)

pure virtual

Implemented in OverlapsJoinHashTable, BaselineJoinHashTable, and PerfectJoinHashTable.

std::vector< int > HashJoin::collectFragmentIds ( const std::vector< Fragmenter_Namespace::FragmentInfo > & fragments )

static

Definition at line 452 of file HashJoin.cpp.

References gpu_enabled::sort(), and shared::transform().

Referenced by OverlapsJoinHashTable::generateCacheKey(), HashtableRecycler::getHashtableAccessPathInfo(), RangeJoinHashTable::reifyWithLayout(), and OverlapsJoinHashTable::reifyWithLayout().

                                                                   {
   auto const fragment_id = [](auto const& frag_info) { return frag_info.fragmentId; };
   std::vector<int> frag_ids(fragments.size());
   std::transform(fragments.cbegin(), fragments.cend(), frag_ids.begin(), fragment_id);
   std::sort(frag_ids.begin(), frag_ids.end());
   return frag_ids;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual size_t HashJoin::countBufferOff ( ) const

pure virtualnoexcept

Implemented in OverlapsJoinHashTable, BaselineJoinHashTable, and PerfectJoinHashTable.

JoinColumn HashJoin::fetchJoinColumn	(	const Analyzer::ColumnVar *	hash_col,
		const std::vector< Fragmenter_Namespace::FragmentInfo > &	fragment_info,
		const Data_Namespace::MemoryLevel	effective_memory_level,
		const int	device_id,
		std::vector< std::shared_ptr< Chunk_NS::Chunk >> &	chunks_owner,
		DeviceAllocator *	dev_buff_owner,
		std::vector< std::shared_ptr< void >> &	malloc_owner,
		Executor *	executor,
		ColumnCacheMap *	column_cache
	)

fetchJoinColumn() calls ColumnFetcher::makeJoinColumn(), then copies the JoinColumn's col_chunks_buff memory onto the GPU if required by the effective_memory_level parameter. The dev_buff_owner parameter will manage the GPU memory.

Definition at line 58 of file HashJoin.cpp.

References Allocator::alloc(), CHECK, JoinColumn::col_chunks_buff, JoinColumn::col_chunks_buff_sz, DeviceAllocator::copyToDevice(), Data_Namespace::GPU_LEVEL, and ColumnFetcher::makeJoinColumn().

Referenced by OverlapsJoinHashTable::fetchColumnsForDevice(), PerfectJoinHashTable::fetchColumnsForDevice(), and BaselineJoinHashTable::fetchColumnsForDevice().

                                   {
   static std::mutex fragment_fetch_mutex;
   std::lock_guard<std::mutex> fragment_fetch_lock(fragment_fetch_mutex);
   try {
     JoinColumn join_column = ColumnFetcher::makeJoinColumn(executor,
                                                            *hash_col,
                                                            fragment_info,
                                                            effective_memory_level,
                                                            device_id,
                                                            dev_buff_owner,
                                                            /*thread_idx=*/0,
                                                            chunks_owner,
                                                            malloc_owner,
                                                            *column_cache);
     if (effective_memory_level == Data_Namespace::GPU_LEVEL) {
       CHECK(dev_buff_owner);
       auto device_col_chunks_buff = dev_buff_owner->alloc(join_column.col_chunks_buff_sz);
       dev_buff_owner->copyToDevice(device_col_chunks_buff,
                                    join_column.col_chunks_buff,
                                    join_column.col_chunks_buff_sz);
       join_column.col_chunks_buff = device_col_chunks_buff;
     }
     return join_column;
   } catch (...) {
     throw FailedToFetchColumn();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void HashJoin::freeHashBufferMemory ( )

inline

Definition at line 323 of file HashJoin.h.

References hash_tables_for_device_.

Referenced by BaselineJoinHashTable::reify(), and PerfectJoinHashTable::reify().

                               {
     auto empty_hash_tables =
         decltype(hash_tables_for_device_)(hash_tables_for_device_.size());
     hash_tables_for_device_.swap(empty_hash_tables);
   }

Here is the caller graph for this function:

virtual size_t HashJoin::getComponentBufferSize ( ) const

protectedpure virtualnoexcept

Implemented in PerfectJoinHashTable, OverlapsJoinHashTable, and BaselineJoinHashTable.

CompositeKeyInfo HashJoin::getCompositeKeyInfo	(	const std::vector< InnerOuter > &	inner_outer_pairs,
		const Executor *	executor,
		const std::vector< InnerOuterStringOpInfos > &	inner_outer_string_op_infos_pairs = `{}`
	)

static

Definition at line 461 of file HashJoin.cpp.

References CHECK, CHECK_EQ, and kENCODING_DICT.

Referenced by RangeJoinHashTable::approximateTupleCount(), BaselineJoinHashTable::initHashTableForDevice(), RangeJoinHashTable::initHashTableOnCpu(), OverlapsJoinHashTable::reify(), BaselineJoinHashTable::reify(), and BaselineJoinHashTable::reifyWithLayout().

                                                                                  {
   CHECK(executor);
   std::vector<const void*> sd_inner_proxy_per_key;
   std::vector<void*> sd_outer_proxy_per_key;
   std::vector<ChunkKey> cache_key_chunks;  // used for the cache key
   const bool has_string_op_infos = inner_outer_string_op_infos_pairs.size();
   if (has_string_op_infos) {
     CHECK_EQ(inner_outer_pairs.size(), inner_outer_string_op_infos_pairs.size());
   }
   size_t string_op_info_pairs_idx = 0;
   for (const auto& inner_outer_pair : inner_outer_pairs) {
     const auto inner_col = inner_outer_pair.first;
     const auto outer_col = inner_outer_pair.second;
     const auto& inner_ti = inner_col->get_type_info();
     const auto& outer_ti = outer_col->get_type_info();
     const auto& inner_column_key = inner_col->getColumnKey();
     ChunkKey cache_key_chunks_for_column{
         inner_column_key.db_id, inner_column_key.table_id, inner_column_key.column_id};
     if (inner_ti.is_string() &&
         (!(inner_ti.get_comp_param() == outer_ti.get_comp_param()) ||
          (has_string_op_infos &&
           (inner_outer_string_op_infos_pairs[string_op_info_pairs_idx].first.size() ||
            inner_outer_string_op_infos_pairs[string_op_info_pairs_idx].second.size())))) {
       CHECK(outer_ti.is_string());
       CHECK(inner_ti.get_compression() == kENCODING_DICT &&
             outer_ti.get_compression() == kENCODING_DICT);
       const auto sd_inner_proxy = executor->getStringDictionaryProxy(
           inner_ti.getStringDictKey(), executor->getRowSetMemoryOwner(), true);
       auto sd_outer_proxy = executor->getStringDictionaryProxy(
           outer_ti.getStringDictKey(), executor->getRowSetMemoryOwner(), true);
       CHECK(sd_inner_proxy && sd_outer_proxy);
       sd_inner_proxy_per_key.push_back(sd_inner_proxy);
       sd_outer_proxy_per_key.push_back(sd_outer_proxy);
       cache_key_chunks_for_column.push_back(sd_outer_proxy->getGeneration());
     } else {
       sd_inner_proxy_per_key.emplace_back();
       sd_outer_proxy_per_key.emplace_back();
     }
     cache_key_chunks.push_back(cache_key_chunks_for_column);
     string_op_info_pairs_idx++;
   }
   return {sd_inner_proxy_per_key, sd_outer_proxy_per_key, cache_key_chunks};
 }

Here is the caller graph for this function:

virtual int HashJoin::getDeviceCount ( ) const

pure virtualnoexcept

Implemented in OverlapsJoinHashTable, BaselineJoinHashTable, and PerfectJoinHashTable.

template<typename T >

const T * HashJoin::getHashJoinColumn ( const Analyzer::Expr * expr )

static

Definition at line 796 of file HashJoin.cpp.

References CHECK, and heavydb.dtypes::T.

                                                              {
   auto* target_expr = expr;
   if (auto cast_expr = dynamic_cast<const Analyzer::UOper*>(expr)) {
     target_expr = cast_expr->get_operand();
   }
   CHECK(target_expr);
   return dynamic_cast<const T*>(target_expr);
 }

virtual std::string HashJoin::getHashJoinType ( ) const

pure virtual

Implemented in OverlapsJoinHashTable, BaselineJoinHashTable, and PerfectJoinHashTable.

HashTable* HashJoin::getHashTableForDevice ( const size_t device_id ) const

inline

Definition at line 281 of file HashJoin.h.

References CHECK_LT, and hash_tables_for_device_.

Referenced by OverlapsJoinHashTable::codegenManyKey(), BaselineJoinHashTable::codegenMatchingSet(), BaselineJoinHashTable::codegenSlot(), BaselineJoinHashTable::getComponentBufferSize(), OverlapsJoinHashTable::getEmittedKeysCount(), OverlapsJoinHashTable::getEntryCount(), BaselineJoinHashTable::getHashType(), OverlapsJoinHashTable::getHashType(), getJoinHashBufferSize(), BaselineJoinHashTable::getKeyBufferSize(), BaselineJoinHashTable::toSet(), and OverlapsJoinHashTable::toSet().

                                                                  {
     CHECK_LT(device_id, hash_tables_for_device_.size());
     return hash_tables_for_device_[device_id].get();
   }

Here is the caller graph for this function:

virtual HashType HashJoin::getHashType ( ) const

pure virtualnoexcept

Implemented in OverlapsJoinHashTable, RangeJoinHashTable, BaselineJoinHashTable, and PerfectJoinHashTable.

static std::string HashJoin::getHashTypeString ( HashType ht )

inlinestaticnoexcept

Definition at line 165 of file HashJoin.h.

Referenced by BaselineJoinHashTableBuilder::allocateDeviceMemory(), BaselineJoinHashTable::getInstance(), PerfectJoinHashTable::getInstance(), OverlapsJoinHashTable::getInstance(), BaselineJoinHashTableBuilder::initHashTableOnCpu(), RangeJoinHashTable::reifyWithLayout(), OverlapsJoinHashTable::reifyWithLayout(), HashingSchemeRecycler::toString(), PerfectJoinHashTable::toString(), BaselineJoinHashTable::toString(), and OverlapsJoinHashTable::toString().

                                                            {
     const char* HashTypeStrings[3] = {"OneToOne", "OneToMany", "ManyToMany"};
     return HashTypeStrings[static_cast<int>(ht)];
   };

Here is the caller graph for this function:

virtual shared::TableKey HashJoin::getInnerTableId ( ) const

pure virtualnoexcept

Implemented in OverlapsJoinHashTable, BaselineJoinHashTable, and PerfectJoinHashTable.

Referenced by OverlapsJoinHashTable::getInnerTableId(), RangeJoinHashTable::getInstance(), OverlapsJoinHashTable::getInstance(), RangeJoinHashTable::reifyWithLayout(), and OverlapsJoinHashTable::reifyWithLayout().

Here is the caller graph for this function:

static shared::TableKey HashJoin::getInnerTableId ( const std::vector< InnerOuter > & inner_outer_pairs )

inlinestatic

Definition at line 251 of file HashJoin.h.

References CHECK.

                                                       {
     CHECK(!inner_outer_pairs.empty());
     const auto first_inner_col = inner_outer_pairs.front().first;
     return first_inner_col->getTableKey();
   }

virtual int HashJoin::getInnerTableRteIdx ( ) const

pure virtualnoexcept

Implemented in OverlapsJoinHashTable, BaselineJoinHashTable, and PerfectJoinHashTable.

std::shared_ptr< HashJoin > HashJoin::getInstance	(	const std::shared_ptr< Analyzer::BinOper >	qual_bin_oper,
		const std::vector< InputTableInfo > &	query_infos,
		const Data_Namespace::MemoryLevel	memory_level,
		const JoinType	join_type,
		const HashType	preferred_hash_type,
		const int	device_count,
		ColumnCacheMap &	column_cache,
		Executor *	executor,
		const HashTableBuildDagMap &	hashtable_build_dag_map,
		const RegisteredQueryHint &	query_hint,
		const TableIdToNodeMap &	table_id_to_node_map
	)

static

Make hash table from an in-flight SQL query's parse tree etc.

Definition at line 283 of file HashJoin.cpp.

References CHECK, CHECK_EQ, CHECK_GT, coalesce_singleton_equi_join(), CPU, DEBUG_TIMER, g_enable_overlaps_hashjoin, BaselineJoinHashTable::getInstance(), PerfectJoinHashTable::getInstance(), OverlapsJoinHashTable::getInstance(), GPU, Data_Namespace::GPU_LEVEL, VLOG, and VLOGGING.

Referenced by Executor::buildHashTableForQualifier(), and getSyntheticInstance().

                                                   {
   auto timer = DEBUG_TIMER(__func__);
   std::shared_ptr<HashJoin> join_hash_table;
   CHECK_GT(device_count, 0);
   if (!g_enable_overlaps_hashjoin && qual_bin_oper->is_overlaps_oper()) {
     throw std::runtime_error(
         "Overlaps hash join disabled, attempting to fall back to loop join");
   }
   if (qual_bin_oper->is_overlaps_oper()) {
     VLOG(1) << "Trying to build geo hash table:";
     join_hash_table = OverlapsJoinHashTable::getInstance(qual_bin_oper,
                                                          query_infos,
                                                          memory_level,
                                                          join_type,
                                                          device_count,
                                                          column_cache,
                                                          executor,
                                                          hashtable_build_dag_map,
                                                          query_hint,
                                                          table_id_to_node_map);
   } else if (dynamic_cast<const Analyzer::ExpressionTuple*>(
                  qual_bin_oper->get_left_operand())) {
     VLOG(1) << "Trying to build keyed hash table:";
     join_hash_table = BaselineJoinHashTable::getInstance(qual_bin_oper,
                                                          query_infos,
                                                          memory_level,
                                                          join_type,
                                                          preferred_hash_type,
                                                          device_count,
                                                          column_cache,
                                                          executor,
                                                          hashtable_build_dag_map,
                                                          query_hint,
                                                          table_id_to_node_map);
   } else {
     try {
       VLOG(1) << "Trying to build perfect hash table:";
       join_hash_table = PerfectJoinHashTable::getInstance(qual_bin_oper,
                                                           query_infos,
                                                           memory_level,
                                                           join_type,
                                                           preferred_hash_type,
                                                           device_count,
                                                           column_cache,
                                                           executor,
                                                           hashtable_build_dag_map,
                                                           query_hint,
                                                           table_id_to_node_map);
     } catch (JoinHashTableTooBig& e) {
       throw e;
     } catch (TooManyHashEntries&) {
       const auto join_quals = coalesce_singleton_equi_join(qual_bin_oper);
       CHECK_EQ(join_quals.size(), size_t(1));
       const auto join_qual =
           std::dynamic_pointer_cast<Analyzer::BinOper>(join_quals.front());
       VLOG(1) << "Trying to build keyed hash table after perfect hash table:";
       join_hash_table = BaselineJoinHashTable::getInstance(join_qual,
                                                            query_infos,
                                                            memory_level,
                                                            join_type,
                                                            preferred_hash_type,
                                                            device_count,
                                                            column_cache,
                                                            executor,
                                                            hashtable_build_dag_map,
                                                            query_hint,
                                                            table_id_to_node_map);
     }
   }
   CHECK(join_hash_table);
   if (VLOGGING(2)) {
     if (join_hash_table->getMemoryLevel() == Data_Namespace::MemoryLevel::GPU_LEVEL) {
       for (int device_id = 0; device_id < join_hash_table->getDeviceCount();
            ++device_id) {
         if (join_hash_table->getJoinHashBufferSize(ExecutorDeviceType::GPU, device_id) <=
             1000) {
           VLOG(2) << "Built GPU hash table: "
                   << join_hash_table->toString(ExecutorDeviceType::GPU, device_id);
         }
       }
     } else {
       if (join_hash_table->getJoinHashBufferSize(ExecutorDeviceType::CPU) <= 1000) {
         VLOG(2) << "Built CPU hash table: "
                 << join_hash_table->toString(ExecutorDeviceType::CPU);
       }
     }
   }
   return join_hash_table;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int8_t* HashJoin::getJoinHashBuffer	(	const ExecutorDeviceType	device_type,
		const int	device_id
	)		const

inline

Definition at line 300 of file HashJoin.h.

References CHECK, CHECK_LT, CPU, and hash_tables_for_device_.

Referenced by PerfectJoinHashTable::toSet(), BaselineJoinHashTable::toSet(), OverlapsJoinHashTable::toSet(), PerfectJoinHashTable::toString(), BaselineJoinHashTable::toString(), OverlapsJoinHashTable::toString(), and anonymous_namespace{HashJoin.cpp}::toStringFlat().

                                                        {
     // TODO: just make device_id a size_t
     CHECK_LT(size_t(device_id), hash_tables_for_device_.size());
     if (!hash_tables_for_device_[device_id]) {
       return nullptr;
     }
     CHECK(hash_tables_for_device_[device_id]);
     auto hash_table = hash_tables_for_device_[device_id].get();
 #ifdef HAVE_CUDA
     if (device_type == ExecutorDeviceType::CPU) {
       return hash_table->getCpuBuffer();
     } else {
       CHECK(hash_table);
       const auto gpu_buff = hash_table->getGpuBuffer();
       return gpu_buff;
     }
 #else
     CHECK(device_type == ExecutorDeviceType::CPU);
     return hash_table->getCpuBuffer();
 #endif
   }

Here is the caller graph for this function:

size_t HashJoin::getJoinHashBufferSize ( const ExecutorDeviceType device_type )

inline

Definition at line 286 of file HashJoin.h.

References CHECK, and CPU.

Referenced by PerfectJoinHashTable::toSet(), PerfectJoinHashTable::toString(), and anonymous_namespace{HashJoin.cpp}::toStringFlat().

                                                                      {
     CHECK(device_type == ExecutorDeviceType::CPU);
     return getJoinHashBufferSize(device_type, 0);
   }

Here is the caller graph for this function:

size_t HashJoin::getJoinHashBufferSize	(	const ExecutorDeviceType	device_type,
		const int	device_id
	)		const

inline

Definition at line 291 of file HashJoin.h.

References getHashTableForDevice().

                                                           {
     auto hash_table = getHashTableForDevice(device_id);
     if (!hash_table) {
       return 0;
     }
     return hash_table->getHashTableBufferSize(device_type);
   }

Here is the call graph for this function:

virtual Data_Namespace::MemoryLevel HashJoin::getMemoryLevel ( ) const

pure virtualnoexcept

Implemented in OverlapsJoinHashTable, BaselineJoinHashTable, and PerfectJoinHashTable.

std::pair< const StringDictionaryProxy , StringDictionaryProxy > HashJoin::getStrDictProxies	(	const InnerOuter &	cols,
		const Executor *	executor,
		const bool	has_string_ops
	)

static

Definition at line 385 of file HashJoin.cpp.

References CHECK, CHECK_EQ, and Analyzer::Expr::get_type_info().

Referenced by translateInnerToOuterStrDictProxies().

                                                        {
   const auto inner_col = cols.first;
   CHECK(inner_col);
   const auto inner_ti = inner_col->get_type_info();
   const auto outer_col = dynamic_cast<const Analyzer::ColumnVar*>(cols.second);
   std::pair<const StringDictionaryProxy*, StringDictionaryProxy*>
       inner_outer_str_dict_proxies{nullptr, nullptr};
   if (inner_ti.is_string() && outer_col) {
     const auto& outer_ti = outer_col->get_type_info();
     CHECK(outer_ti.is_string());
     inner_outer_str_dict_proxies.first =
         executor->getStringDictionaryProxy(inner_ti.getStringDictKey(), true);
     CHECK(inner_outer_str_dict_proxies.first);
     inner_outer_str_dict_proxies.second =
         executor->getStringDictionaryProxy(outer_ti.getStringDictKey(), true);
     CHECK(inner_outer_str_dict_proxies.second);
     if (!has_string_ops &&
         *inner_outer_str_dict_proxies.first == *inner_outer_str_dict_proxies.second) {
       // Dictionaries are the same - don't need to translate
       CHECK_EQ(inner_ti.getStringDictKey(), outer_ti.getStringDictKey());
       inner_outer_str_dict_proxies.first = nullptr;
       inner_outer_str_dict_proxies.second = nullptr;
     }
   }
   return inner_outer_str_dict_proxies;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::shared_ptr< HashJoin > HashJoin::getSyntheticInstance	(	std::string_view	table1,
		std::string_view	column1,
		const Catalog_Namespace::Catalog &	catalog1,
		std::string_view	table2,
		std::string_view	column2,
		const Catalog_Namespace::Catalog &	catalog2,
		const Data_Namespace::MemoryLevel	memory_level,
		const HashType	preferred_hash_type,
		const int	device_count,
		ColumnCacheMap &	column_cache,
		Executor *	executor
	)

static

Make hash table from named tables and columns (such as for testing).

Definition at line 673 of file HashJoin.cpp.

References RegisteredQueryHint::defaults(), getInstance(), getSyntheticColumnVar(), getSyntheticInputTableInfo(), INNER, kBOOLEAN, kEQ, kONE, setupSyntheticCaching(), and ScalarExprVisitor< T >::visit().

                         {
   auto a1 = getSyntheticColumnVar(table1, column1, 0, catalog1);
   auto a2 = getSyntheticColumnVar(table2, column2, 1, catalog2);
 
   auto qual_bin_oper = std::make_shared<Analyzer::BinOper>(kBOOLEAN, kEQ, kONE, a1, a2);
 
   std::set<const Analyzer::ColumnVar*> cvs =
       AllColumnVarsVisitor().visit(qual_bin_oper.get());
   auto query_infos = getSyntheticInputTableInfo(cvs, executor);
   setupSyntheticCaching(cvs, executor);
   RegisteredQueryHint query_hint = RegisteredQueryHint::defaults();
 
   auto hash_table = HashJoin::getInstance(qual_bin_oper,
                                           query_infos,
                                           memory_level,
                                           JoinType::INNER,
                                           preferred_hash_type,
                                           device_count,
                                           column_cache,
                                           executor,
                                           {},
                                           query_hint,
                                           {});
   return hash_table;
 }

Here is the call graph for this function:

std::shared_ptr< HashJoin > HashJoin::getSyntheticInstance	(	const std::shared_ptr< Analyzer::BinOper >	qual_bin_oper,
		const Data_Namespace::MemoryLevel	memory_level,
		const HashType	preferred_hash_type,
		const int	device_count,
		ColumnCacheMap &	column_cache,
		Executor *	executor
	)

static

Make hash table from named tables and columns (such as for testing).

Definition at line 711 of file HashJoin.cpp.

References RegisteredQueryHint::defaults(), getInstance(), getSyntheticInputTableInfo(), INNER, setupSyntheticCaching(), and ScalarExprVisitor< T >::visit().

                         {
   std::set<const Analyzer::ColumnVar*> cvs =
       AllColumnVarsVisitor().visit(qual_bin_oper.get());
   auto query_infos = getSyntheticInputTableInfo(cvs, executor);
   setupSyntheticCaching(cvs, executor);
   RegisteredQueryHint query_hint = RegisteredQueryHint::defaults();
 
   auto hash_table = HashJoin::getInstance(qual_bin_oper,
                                           query_infos,
                                           memory_level,
                                           JoinType::INNER,
                                           preferred_hash_type,
                                           device_count,
                                           column_cache,
                                           executor,
                                           {},
                                           query_hint,
                                           {});
   return hash_table;
 }

Here is the call graph for this function:

std::pair< std::string, std::shared_ptr< HashJoin > > HashJoin::getSyntheticInstance	(	std::vector< std::shared_ptr< Analyzer::BinOper >>	qual_bin_opers,
		const Data_Namespace::MemoryLevel	memory_level,
		const HashType	preferred_hash_type,
		const int	device_count,
		ColumnCacheMap &	column_cache,
		Executor *	executor
	)

static

Definition at line 738 of file HashJoin.cpp.

References RegisteredQueryHint::defaults(), getInstance(), getSyntheticInputTableInfo(), INNER, setupSyntheticCaching(), and ScalarExprVisitor< T >::visit().

                         {
   std::set<const Analyzer::ColumnVar*> cvs;
   for (auto& qual : qual_bin_opers) {
     auto cv = AllColumnVarsVisitor().visit(qual.get());
     cvs.insert(cv.begin(), cv.end());
   }
   auto query_infos = getSyntheticInputTableInfo(cvs, executor);
   setupSyntheticCaching(cvs, executor);
   RegisteredQueryHint query_hint = RegisteredQueryHint::defaults();
   std::shared_ptr<HashJoin> hash_table;
   std::string error_msg;
   for (auto& qual : qual_bin_opers) {
     try {
       auto candidate_hash_table = HashJoin::getInstance(qual,
                                                         query_infos,
                                                         memory_level,
                                                         JoinType::INNER,
                                                         preferred_hash_type,
                                                         device_count,
                                                         column_cache,
                                                         executor,
                                                         {},
                                                         query_hint,
                                                         {});
       if (candidate_hash_table) {
         hash_table = candidate_hash_table;
       }
     } catch (HashJoinFail& e) {
       error_msg = e.what();
       continue;
     }
   }
   return std::make_pair(error_msg, hash_table);
 }

Here is the call graph for this function:

virtual bool HashJoin::isBitwiseEq ( ) const

pure virtual

Implemented in OverlapsJoinHashTable, PerfectJoinHashTable, and BaselineJoinHashTable.

static bool HashJoin::layoutRequiresAdditionalBuffers ( HashType layout )

inlinestaticnoexcept

Definition at line 161 of file HashJoin.h.

References ManyToMany, and OneToMany.

Referenced by BaselineJoinHashTableBuilder::allocateDeviceMemory(), BaselineJoinHashTable::countBufferOff(), OverlapsJoinHashTable::countBufferOff(), BaselineJoinHashTable::getKeyBufferSize(), OverlapsJoinHashTable::getKeyBufferSize(), RangeJoinHashTable::initHashTableOnCpu(), OverlapsJoinHashTable::initHashTableOnCpu(), BaselineJoinHashTableBuilder::initHashTableOnCpu(), BaselineJoinHashTableBuilder::initHashTableOnGpu(), BaselineJoinHashTable::payloadBufferOff(), OverlapsJoinHashTable::payloadBufferOff(), RangeJoinHashTable::reifyForDevice(), OverlapsJoinHashTable::reifyForDevice(), and OverlapsJoinHashTable::reifyWithLayout().

                                                                         {
     return (layout == HashType::ManyToMany || layout == HashType::OneToMany);
   }

Here is the caller graph for this function:

std::pair< InnerOuter, InnerOuterStringOpInfos > HashJoin::normalizeColumnPair	(	const Analyzer::Expr *	lhs,
		const Analyzer::Expr *	rhs,
		const TemporaryTables *	temporary_tables,
		const bool	is_overlaps_join = `false`
	)

static

Definition at line 805 of file HashJoin.cpp.

References CHECK, CHECK_GT, get_column_descriptor_maybe(), get_column_type(), SQLTypeInfo::get_precision(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_type(), Analyzer::Expr::get_type_info(), SQLTypeInfo::get_type_name(), is_constructed_point(), SQLTypeInfo::is_decimal(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_string(), SQLTypeInfo::is_time(), kCAST, kENCODING_DICT, kPOINT, LHS, RHS, gpu_enabled::swap(), UNKNOWN, and ScalarExprVisitor< T >::visit().

Referenced by anonymous_namespace{PerfectJoinHashTable.cpp}::get_cols(), anonymous_namespace{HashJoin.cpp}::get_cols(), normalizeColumnPairs(), and QueryPlanDagExtractor::normalizeColumnsPair().

                                  {
   SQLTypeInfo lhs_ti = lhs->get_type_info();
   SQLTypeInfo rhs_ti = rhs->get_type_info();
   if (!is_overlaps_join) {
     if (lhs_ti.get_type() != rhs_ti.get_type()) {
       throw HashJoinFail("Equijoin types must be identical, found: " +
                          lhs_ti.get_type_name() + ", " + rhs_ti.get_type_name());
     }
     if (!lhs_ti.is_integer() && !lhs_ti.is_time() && !lhs_ti.is_string() &&
         !lhs_ti.is_decimal()) {
       throw HashJoinFail("Cannot apply hash join to inner column type " +
                          lhs_ti.get_type_name());
     }
     // Decimal types should be identical.
     if (lhs_ti.is_decimal() && (lhs_ti.get_scale() != rhs_ti.get_scale() ||
                                 lhs_ti.get_precision() != rhs_ti.get_precision())) {
       throw HashJoinFail("Equijoin with different decimal types");
     }
   }
 
   const auto lhs_cast = dynamic_cast<const Analyzer::UOper*>(lhs);
   const auto rhs_cast = dynamic_cast<const Analyzer::UOper*>(rhs);
   if (lhs_ti.is_string() && (static_cast<bool>(lhs_cast) != static_cast<bool>(rhs_cast) ||
                              (lhs_cast && lhs_cast->get_optype() != kCAST) ||
                              (rhs_cast && rhs_cast->get_optype() != kCAST))) {
     throw HashJoinFail(
         "Cannot use hash join for given expression (non-cast unary operator)");
   }
   // Casts to decimal are not suported.
   if (lhs_ti.is_decimal() && (lhs_cast || rhs_cast)) {
     throw HashJoinFail("Cannot use hash join for given expression (cast to decimal)");
   }
   auto lhs_col = getHashJoinColumn<Analyzer::ColumnVar>(lhs);
   auto rhs_col = getHashJoinColumn<Analyzer::ColumnVar>(rhs);
 
   const auto lhs_string_oper = getHashJoinColumn<Analyzer::StringOper>(lhs);
   const auto rhs_string_oper = getHashJoinColumn<Analyzer::StringOper>(rhs);
 
   auto process_string_op_infos = [](const auto& string_oper, auto& col, auto& ti) {
     std::vector<StringOps_Namespace::StringOpInfo> string_op_infos;
     if (string_oper) {
       col = dynamic_cast<const Analyzer::ColumnVar*>(string_oper->getArg(0));
       if (!col) {
         // Todo (todd): Allow for non-colvar inputs into string operators for
         // join predicates
         // We now guard against non constant/colvar/stringoper inputs
         // in Analyzer::StringOper::check_operand_types, but keeping this to not
         // depend on that logic if and when it changes as allowing non-colvar inputs
         // for hash joins will be additional work on top of allowing them
         // outside of join predicates
         throw HashJoinFail(
             "Hash joins involving string operators currently restricted to column inputs "
             "(i.e. not case statements).");
       }
       ti = col->get_type_info();
       CHECK(ti.is_dict_encoded_string());
       const auto chained_string_op_exprs = string_oper->getChainedStringOpExprs();
       CHECK_GT(chained_string_op_exprs.size(), 0UL);
       for (const auto& chained_string_op_expr : chained_string_op_exprs) {
         auto chained_string_op =
             dynamic_cast<const Analyzer::StringOper*>(chained_string_op_expr.get());
         CHECK(chained_string_op);
         StringOps_Namespace::StringOpInfo string_op_info(
             chained_string_op->get_kind(),
             chained_string_op->get_type_info(),
             chained_string_op->getLiteralArgs());
         string_op_infos.emplace_back(string_op_info);
       }
     }
     return string_op_infos;
   };
 
   auto outer_string_op_infos = process_string_op_infos(lhs_string_oper, lhs_col, lhs_ti);
   auto inner_string_op_infos = process_string_op_infos(rhs_string_oper, rhs_col, rhs_ti);
 
   if (!lhs_col && !rhs_col) {
     throw HashJoinFail(
         "Cannot use hash join for given expression (both lhs and rhs are invalid)",
         InnerQualDecision::UNKNOWN);
   }
 
   const Analyzer::ColumnVar* inner_col{nullptr};
   const Analyzer::ColumnVar* outer_col{nullptr};
   auto outer_ti = lhs_ti;
   auto inner_ti = rhs_ti;
   const Analyzer::Expr* outer_expr{lhs};
   InnerQualDecision inner_qual_decision = InnerQualDecision::UNKNOWN;
   if (!lhs_col || (rhs_col && lhs_col->get_rte_idx() < rhs_col->get_rte_idx())) {
     inner_qual_decision = InnerQualDecision::RHS;
     inner_col = rhs_col;
     outer_col = lhs_col;
   } else {
     inner_qual_decision = InnerQualDecision::LHS;
     if (lhs_col && lhs_col->get_rte_idx() == 0) {
       throw HashJoinFail(
           "Cannot use hash join for given expression (lhs' rte idx is zero)",
           inner_qual_decision);
     }
     inner_col = lhs_col;
     outer_col = rhs_col;
     std::swap(outer_ti, inner_ti);
     std::swap(outer_string_op_infos, inner_string_op_infos);
     outer_expr = rhs;
   }
   if (!inner_col) {
     throw HashJoinFail("Cannot use hash join for given expression (invalid inner col)",
                        inner_qual_decision);
   }
   if (!outer_col) {
     // check whether outer_col is a constant, i.e., inner_col = K;
     const auto outer_constant_col = dynamic_cast<const Analyzer::Constant*>(outer_expr);
     if (outer_constant_col) {
       throw HashJoinFail(
           "Cannot use hash join for given expression: try to join with a constant "
           "value",
           inner_qual_decision);
     }
     MaxRangeTableIndexVisitor rte_idx_visitor;
     int outer_rte_idx = rte_idx_visitor.visit(outer_expr);
     // The inner column candidate is not actually inner; the outer
     // expression contains columns which are at least as deep.
     if (inner_col->get_rte_idx() <= outer_rte_idx) {
       throw HashJoinFail(
           "Cannot use hash join for given expression (inner's rte <= outer's rte)",
           inner_qual_decision);
     }
   }
   // We need to fetch the actual type information from the catalog since Analyzer
   // always reports nullable as true for inner table columns in left joins.
   const auto& column_key = inner_col->getColumnKey();
   const auto inner_col_cd = get_column_descriptor_maybe(column_key);
   const auto inner_col_real_ti = get_column_type(
       column_key.column_id, column_key.table_id, inner_col_cd, temporary_tables);
   const auto& outer_col_ti =
       !(dynamic_cast<const Analyzer::FunctionOper*>(lhs)) && outer_col
           ? outer_col->get_type_info()
           : outer_ti;
   // Casts from decimal are not supported.
   if ((inner_col_real_ti.is_decimal() || outer_col_ti.is_decimal()) &&
       (lhs_cast || rhs_cast)) {
     throw HashJoinFail("Cannot use hash join for given expression (cast from decimal)");
   }
   if (is_overlaps_join) {
     if (!inner_col_real_ti.is_array()) {
       throw HashJoinFail(
           "Overlaps join only supported for inner columns with array type");
     }
     auto is_bounds_array = [](const auto ti) {
       return ti.is_fixlen_array() && ti.get_size() == 32;
     };
     if (!is_bounds_array(inner_col_real_ti)) {
       throw HashJoinFail(
           "Overlaps join only supported for 4-element double fixed length arrays");
     }
     if (!(outer_col_ti.get_type() == kPOINT || is_bounds_array(outer_col_ti) ||
           is_constructed_point(outer_expr))) {
       throw HashJoinFail(
           "Overlaps join only supported for geometry outer columns of type point, "
           "geometry columns with bounds or constructed points");
     }
   } else {
     if (!(inner_col_real_ti.is_integer() || inner_col_real_ti.is_time() ||
           inner_col_real_ti.is_decimal() ||
           (inner_col_real_ti.is_string() &&
            inner_col_real_ti.get_compression() == kENCODING_DICT))) {
       throw HashJoinFail(
           "Can only apply hash join to integer-like types and dictionary encoded "
           "strings");
     }
   }
 
   auto normalized_inner_col = inner_col;
   auto normalized_outer_col = outer_col ? outer_col : outer_expr;
 
   const auto& normalized_inner_ti = normalized_inner_col->get_type_info();
   const auto& normalized_outer_ti = normalized_outer_col->get_type_info();
 
   if (normalized_inner_ti.is_string() != normalized_outer_ti.is_string()) {
     throw HashJoinFail(std::string("Could not build hash tables for incompatible types " +
                                    normalized_inner_ti.get_type_name() + " and " +
                                    normalized_outer_ti.get_type_name()));
   }
   return std::make_pair(std::make_pair(normalized_inner_col, normalized_outer_col),
                         std::make_pair(inner_string_op_infos, outer_string_op_infos));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair< std::vector< InnerOuter >, std::vector< InnerOuterStringOpInfos > > HashJoin::normalizeColumnPairs	(	const Analyzer::BinOper *	condition,
		const TemporaryTables *	temporary_tables
	)

static

Definition at line 996 of file HashJoin.cpp.

References CHECK, CHECK_EQ, Analyzer::BinOper::get_left_operand(), Analyzer::BinOper::get_right_operand(), Analyzer::BinOper::is_overlaps_oper(), normalizeColumnPair(), and run_benchmark_import::result.

Referenced by anonymous_namespace{FromTableReordering.cpp}::get_join_qual_cost(), BaselineJoinHashTable::getInstance(), OverlapsJoinHashTable::getInstance(), BaselineJoinHashTable::reifyWithLayout(), and Executor::skipFragmentPair().

                                                                         {
   std::pair<std::vector<InnerOuter>, std::vector<InnerOuterStringOpInfos>> result;
   const auto lhs_tuple_expr =
       dynamic_cast<const Analyzer::ExpressionTuple*>(condition->get_left_operand());
   const auto rhs_tuple_expr =
       dynamic_cast<const Analyzer::ExpressionTuple*>(condition->get_right_operand());
 
   CHECK_EQ(static_cast<bool>(lhs_tuple_expr), static_cast<bool>(rhs_tuple_expr));
   if (lhs_tuple_expr) {
     const auto& lhs_tuple = lhs_tuple_expr->getTuple();
     const auto& rhs_tuple = rhs_tuple_expr->getTuple();
     CHECK_EQ(lhs_tuple.size(), rhs_tuple.size());
     for (size_t i = 0; i < lhs_tuple.size(); ++i) {
       const auto col_pair = normalizeColumnPair(lhs_tuple[i].get(),
                                                 rhs_tuple[i].get(),
                                                 temporary_tables,
                                                 condition->is_overlaps_oper());
       result.first.emplace_back(col_pair.first);
       result.second.emplace_back(col_pair.second);
     }
   } else {
     CHECK(!lhs_tuple_expr && !rhs_tuple_expr);
     const auto col_pair = normalizeColumnPair(condition->get_left_operand(),
                                               condition->get_right_operand(),
                                               temporary_tables,
                                               condition->is_overlaps_oper());
     result.first.emplace_back(col_pair.first);
     result.second.emplace_back(col_pair.second);
   }
 
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual size_t HashJoin::offsetBufferOff ( ) const

pure virtualnoexcept

Implemented in OverlapsJoinHashTable, BaselineJoinHashTable, and PerfectJoinHashTable.

virtual size_t HashJoin::payloadBufferOff ( ) const

pure virtualnoexcept

Implemented in OverlapsJoinHashTable, BaselineJoinHashTable, and PerfectJoinHashTable.

virtual DecodedJoinHashBufferSet HashJoin::toSet	(	const ExecutorDeviceType	device_type,
		const int	device_id
	)		const

pure virtual

Implemented in OverlapsJoinHashTable, BaselineJoinHashTable, and PerfectJoinHashTable.

virtual std::string HashJoin::toString	(	const ExecutorDeviceType	device_type,
		const int	device_id = `0`,
		bool	raw = `false`
	)		const

pure virtual

Implemented in OverlapsJoinHashTable, BaselineJoinHashTable, and PerfectJoinHashTable.

std::string HashJoin::toStringFlat32	(	const ExecutorDeviceType	device_type,
		const int	device_id
	)		const

virtual

Definition at line 121 of file HashJoin.cpp.

                                                                 {
   return toStringFlat<int32_t>(this, device_type, device_id);
 }

std::string HashJoin::toStringFlat64	(	const ExecutorDeviceType	device_type,
		const int	device_id
	)		const

virtual

Definition at line 116 of file HashJoin.cpp.

                                                                 {
   return toStringFlat<int64_t>(this, device_type, device_id);
 }

std::vector< const StringDictionaryProxy::IdMap * > HashJoin::translateCompositeStrDictProxies	(	const CompositeKeyInfo &	composite_key_info,
		const std::vector< InnerOuterStringOpInfos > &	string_op_infos_for_keys,
		const Executor *	executor
	)

static

Definition at line 509 of file HashJoin.cpp.

References CHECK, CHECK_EQ, CHECK_NE, CompositeKeyInfo::sd_inner_proxy_per_key, and CompositeKeyInfo::sd_outer_proxy_per_key.

Referenced by BaselineJoinHashTable::reifyWithLayout().

                               {
   const auto& inner_proxies = composite_key_info.sd_inner_proxy_per_key;
   const auto& outer_proxies = composite_key_info.sd_outer_proxy_per_key;
   const size_t num_proxies = inner_proxies.size();
   CHECK_EQ(num_proxies, outer_proxies.size());
   std::vector<const StringDictionaryProxy::IdMap*> proxy_translation_maps;
   proxy_translation_maps.reserve(num_proxies);
   for (size_t proxy_pair_idx = 0; proxy_pair_idx < num_proxies; ++proxy_pair_idx) {
     const bool translate_proxies =
         inner_proxies[proxy_pair_idx] && outer_proxies[proxy_pair_idx];
     if (translate_proxies) {
       const auto inner_proxy =
           reinterpret_cast<const StringDictionaryProxy*>(inner_proxies[proxy_pair_idx]);
       auto outer_proxy =
           reinterpret_cast<StringDictionaryProxy*>(outer_proxies[proxy_pair_idx]);
       CHECK(inner_proxy);
       CHECK(outer_proxy);
 
       CHECK_NE(inner_proxy->getDictKey(), outer_proxy->getDictKey());
       proxy_translation_maps.emplace_back(
           executor->getJoinIntersectionStringProxyTranslationMap(
               inner_proxy,
               outer_proxy,
               string_op_infos_for_keys[proxy_pair_idx].first,
               string_op_infos_for_keys[proxy_pair_idx].second,
               executor->getRowSetMemoryOwner()));
     } else {
       proxy_translation_maps.emplace_back(nullptr);
     }
   }
   return proxy_translation_maps;
 }

Here is the caller graph for this function:

const StringDictionaryProxy::IdMap * HashJoin::translateInnerToOuterStrDictProxies	(	const InnerOuter &	cols,
		const InnerOuterStringOpInfos &	inner_outer_string_op_infos,
		ExpressionRange &	old_col_range,
		const Executor *	executor
	)

static

Definition at line 414 of file HashJoin.cpp.

References CHECK, ExpressionRange::getIntMax(), ExpressionRange::getIntMin(), getStrDictProxies(), ExpressionRange::hasNulls(), ExpressionRange::makeIntRange(), and StringDictionaryProxy::TranslationMap< T >::size().

Referenced by PerfectJoinHashTable::reify().

                               {
   const bool has_string_ops = inner_outer_string_op_infos.first.size() ||
                               inner_outer_string_op_infos.second.size();
   const auto inner_outer_proxies =
       HashJoin::getStrDictProxies(cols, executor, has_string_ops);
   const bool translate_dictionary =
       inner_outer_proxies.first && inner_outer_proxies.second;
   if (translate_dictionary) {
     const auto& inner_dict_id = inner_outer_proxies.first->getDictKey();
     const auto& outer_dict_id = inner_outer_proxies.second->getDictKey();
     CHECK(has_string_ops || inner_dict_id != outer_dict_id);
     const auto id_map = executor->getJoinIntersectionStringProxyTranslationMap(
         inner_outer_proxies.first,
         inner_outer_proxies.second,
         inner_outer_string_op_infos.first,
         inner_outer_string_op_infos.second,
         executor->getRowSetMemoryOwner());
     if (!inner_outer_string_op_infos.second.empty()) {
       // String op was applied to lhs table,
       // need to expand column range appropriately
       col_range = ExpressionRange::makeIntRange(
           std::min(col_range.getIntMin(),
                    static_cast<int64_t>(
                        inner_outer_proxies.second->transientEntryCount() + 1) *
                        -1),
           col_range.getIntMax(),
           0,
           col_range.hasNulls());
     }
     return id_map;
   }
   return nullptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

std::vector<std::shared_ptr<HashTable> > HashJoin::hash_tables_for_device_

protected

The documentation for this class was generated from the following files:

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/JoinHashTable/HashJoin.h
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/JoinHashTable/HashJoin.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Member Function Documentation

Member Data Documentation