73 const std::shared_ptr<Analyzer::BinOper> condition,
75 const std::vector<InputTableInfo>& query_infos,
78 const int device_count,
86 auto range_expr_col_var =
88 if (!range_expr_col_var || !range_expr_col_var->get_type_info().is_geometry()) {
89 throw HashJoinFail(
"Could not build hash tables for range join | " +
92 auto cat = executor->getCatalog();
94 CHECK(range_expr_col_var->get_type_info().is_geometry());
96 auto coords_cd =
cat->getMetadataForColumn(range_expr_col_var->get_table_id(),
97 range_expr_col_var->get_column_id() + 1);
100 auto range_join_inner_col_expr =
101 makeExpr<Analyzer::ColumnVar>(coords_cd->columnType,
104 range_expr_col_var->get_rte_idx());
106 std::vector<InnerOuter> inner_outer_pairs;
107 inner_outer_pairs.emplace_back(
109 condition->get_left_operand()});
111 const auto& query_info =
116 if (total_entries > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
122 condition.get(), executor, inner_outer_pairs)
125 auto join_hash_table = std::make_shared<RangeJoinHashTable>(condition,
128 range_join_inner_col_expr,
135 hashtable_build_dag_map,
136 table_id_to_node_map);
142 throw HashJoinFail(std::string(
"Could not build a 1-to-1 correspondence for columns "
143 "involved in equijoin | ") +
146 throw HashJoinFail(std::string(
"Could not build hash tables for equijoin | ") +
148 }
catch (
const std::exception& e) {
149 LOG(
FATAL) <<
"Fatal error while attempting to build hash tables for join: "
153 return join_hash_table;
160 const auto& query_info =
164 if (query_info.fragments.empty()) {
171 std::vector<ColumnsForDevice> columns_per_device;
172 const auto catalog =
executor_->getCatalog();
175 auto& data_mgr = catalog->getDataMgr();
176 std::vector<std::vector<Fragmenter_Namespace::FragmentInfo>> fragments_per_device;
177 std::vector<std::unique_ptr<CudaAllocator>> dev_buff_owners;
179 for (
int device_id = 0; device_id <
device_count_; ++device_id) {
180 fragments_per_device.emplace_back(
183 : query_info.fragments);
185 dev_buff_owners.emplace_back(std::make_unique<CudaAllocator>(
191 const auto columns_for_device =
195 ? dev_buff_owners[device_id].
get()
197 columns_per_device.push_back(columns_for_device);
202 const auto bucket_range =
206 CHECK(bucket_range->get_type_info().is_fp() &&
207 bucket_range->get_type_info().get_size() == 8);
209 const auto bucket_range_datum = bucket_range->get_constval();
223 std::vector<InnerOuter> inner_outer_pairs_for_cache_lookup;
224 inner_outer_pairs_for_cache_lookup.emplace_back(
InnerOuter{
227 auto hashtable_access_path_info =
235 fragments_per_device,
238 table_keys_ = hashtable_access_path_info.table_keys;
244 fragments_per_device,
248 inner_outer_pairs_for_cache_lookup.front().first->get_table_id() > 0) {
249 std::vector<int> alternative_table_key{
252 const auto table_keys =
253 std::unordered_set<size_t>{boost::hash_value(alternative_table_key)};
254 std::vector<size_t> per_device_chunk_key(device_count_);
256 for (
int device_id = 0; device_id <
device_count_; ++device_id) {
258 boost::hash_combine(chunk_key_hash,
260 per_device_chunk_key.push_back(chunk_key_hash);
262 inner_outer_pairs_for_cache_lookup,
263 columns_per_device.front().join_columns.front().num_elems,
277 if (
auto generic_hash_table =
281 if (
auto hash_table =
282 std::dynamic_pointer_cast<BaselineHashTable>(generic_hash_table)) {
293 for (
int device_id = 0; device_id <
device_count_; ++device_id) {
294 auto gpu_hash_table = copyCpuHashTableToGpu(hash_table,
296 hash_table->getEntryCount(),
297 hash_table->getEmittedKeysCount(),
316 auto [entry_count, emitted_keys_count] =
322 VLOG(1) <<
"Finalized range join hash table: entry count " << entry_count
323 <<
" hash table size " << hash_table_size;
325 std::vector<std::future<void>> init_threads;
326 for (
int device_id = 0; device_id <
device_count_; ++device_id) {
327 init_threads.push_back(
331 columns_per_device[device_id],
338 for (
auto& init_thread : init_threads) {
341 for (
auto& init_thread : init_threads) {
348 const size_t entry_count,
349 const size_t emitted_keys_count,
357 VLOG(1) <<
"Building range join hash table on CPU.";
368 auto gpu_hash_table = copyCpuHashTableToGpu(
369 hash_table, layout, entry_count, emitted_keys_count, device_id);
383 auto hash_table = initHashTableOnGpu(columns_for_device.
join_columns,
400 std::shared_ptr<BaselineHashTable> RangeJoinHashTable::initHashTableOnGpu(
401 const std::vector<JoinColumn>& join_columns,
402 const std::vector<JoinColumnTypeInfo>& join_column_types,
403 const std::vector<JoinBucketInfo>& join_bucket_info,
405 const size_t entry_count,
406 const size_t emitted_keys_count,
407 const size_t device_id) {
410 VLOG(1) <<
"Building range join hash table on GPU.";
418 CHECK(!join_bucket_info.empty());
420 auto& inverse_bucket_sizes_for_dimension =
421 join_bucket_info[0].inverse_bucket_sizes_for_dimension;
424 inverse_bucket_sizes_for_dimension, allocator);
427 inverse_bucket_sizes_for_dimension.size(),
443 std::string(
"Unrecognized error when initializing GPU range join hash table (") +
451 const std::vector<JoinColumn>& join_columns,
452 const std::vector<JoinColumnTypeInfo>& join_column_types,
453 const std::vector<JoinBucketInfo>& join_bucket_info,
455 const size_t entry_count,
456 const size_t emitted_keys_count) {
458 decltype(std::chrono::steady_clock::now()) ts1, ts2;
459 ts1 = std::chrono::steady_clock::now();
460 const auto composite_key_info =
462 CHECK(!join_columns.empty());
463 CHECK(!join_bucket_info.empty());
466 const auto key_component_count =
467 join_bucket_info[0].inverse_bucket_sizes_for_dimension.size();
473 join_bucket_info[0].inverse_bucket_sizes_for_dimension.data());
477 dummy_str_proxy_translation_maps_ptrs_and_offsets;
479 builder.initHashTableOnCpu(&key_handler,
484 dummy_str_proxy_translation_maps_ptrs_and_offsets,
491 ts2 = std::chrono::steady_clock::now();
493 throw HashJoinFail(std::string(
"Unrecognized error when initializing CPU "
494 "range join hash table (") +
497 std::shared_ptr<BaselineHashTable> hash_table = builder.getHashTable();
498 auto hashtable_build_time =
499 std::chrono::duration_cast<std::chrono::milliseconds>(ts2 - ts1).count();
504 hashtable_build_time);
509 const size_t shard_count,
510 std::vector<ColumnsForDevice>& columns_per_device) {
512 const auto [tuple_count, emitted_keys_count] =
517 const auto entry_count = 2 * std::max(tuple_count,
size_t(1));
519 return std::make_pair(
525 const std::vector<double>& inverse_bucket_sizes_for_dimension,
526 std::vector<ColumnsForDevice>& columns_per_device,
527 const size_t chosen_max_hashtable_size,
528 const double chosen_bucket_threshold) {
545 .bitmap_sz_bits = 11,
550 .sub_bitmap_count = 1,
553 const auto padded_size_bytes = count_distinct_desc.bitmapPaddedSizeBytes();
555 CHECK(!columns_per_device.empty() && !columns_per_device.front().join_columns.empty());
556 if (columns_per_device.front().join_columns.front().num_elems == 0) {
557 return std::make_pair(0, 0);
560 for (
auto& columns_for_device : columns_per_device) {
561 columns_for_device.setBucketInfo(inverse_bucket_sizes_for_dimension,
566 CHECK_EQ(columns_per_device.front().join_columns.size(),
567 columns_per_device.front().join_buckets.size());
569 const auto composite_key_info =
572 std::vector<uint8_t> hll_buffer_all_cpus(thread_count * padded_size_bytes);
573 auto hll_result = &hll_buffer_all_cpus[0];
575 std::vector<int32_t> num_keys_for_row;
576 num_keys_for_row.resize(columns_per_device.front().join_columns[0].num_elems);
580 count_distinct_desc.bitmap_sz_bits,
582 columns_per_device.front().join_columns,
583 columns_per_device.front().join_column_types,
584 columns_per_device.front().join_buckets,
588 for (
int i = 1; i < thread_count; ++i) {
590 hll_result + i * padded_size_bytes,
591 1 << count_distinct_desc.bitmap_sz_bits);
593 return std::make_pair(
hll_size(hll_result, count_distinct_desc.bitmap_sz_bits),
594 num_keys_for_row.size() > 0 ? num_keys_for_row.back() : 0);
597 auto& data_mgr =
executor_->getCatalog()->getDataMgr();
598 std::vector<std::vector<uint8_t>> host_hll_buffers(
device_count_);
599 for (
auto& host_hll_buffer : host_hll_buffers) {
600 host_hll_buffer.resize(count_distinct_desc.bitmapPaddedSizeBytes());
602 std::vector<size_t> emitted_keys_count_device_threads(
device_count_, 0);
603 std::vector<std::future<void>> approximate_distinct_device_threads;
604 for (
int device_id = 0; device_id <
device_count_; ++device_id) {
605 approximate_distinct_device_threads.emplace_back(
std::async(
609 &count_distinct_desc,
612 &emitted_keys_count_device_threads,
614 auto allocator = std::make_unique<CudaAllocator>(
616 auto device_hll_buffer =
617 allocator->alloc(count_distinct_desc.bitmapPaddedSizeBytes());
618 data_mgr.getCudaMgr()->zeroDeviceMem(
620 count_distinct_desc.bitmapPaddedSizeBytes(),
623 const auto& columns_for_device = columns_per_device[device_id];
625 columns_for_device.join_columns, *allocator);
627 CHECK_GT(columns_for_device.join_buckets.size(), 0u);
628 const auto& bucket_sizes_for_dimension =
629 columns_for_device.join_buckets[0].inverse_bucket_sizes_for_dimension;
630 auto bucket_sizes_gpu =
631 allocator->alloc(bucket_sizes_for_dimension.size() *
sizeof(double));
632 allocator->copyToDevice(bucket_sizes_gpu,
633 bucket_sizes_for_dimension.data(),
634 bucket_sizes_for_dimension.size() *
sizeof(double));
635 const size_t row_counts_buffer_sz =
636 columns_per_device.front().join_columns[0].num_elems *
sizeof(int32_t);
637 auto row_counts_buffer = allocator->alloc(row_counts_buffer_sz);
638 data_mgr.getCudaMgr()->zeroDeviceMem(
640 row_counts_buffer_sz,
643 const auto key_handler =
645 bucket_sizes_for_dimension.size(),
647 reinterpret_cast<double*
>(bucket_sizes_gpu));
648 const auto key_handler_gpu =
651 reinterpret_cast<uint8_t*>(device_hll_buffer),
652 count_distinct_desc.bitmap_sz_bits,
653 reinterpret_cast<int32_t*>(row_counts_buffer),
655 columns_for_device.join_columns[0].num_elems,
659 auto& host_emitted_keys_count = emitted_keys_count_device_threads[device_id];
660 allocator->copyFromDevice(
661 &host_emitted_keys_count,
663 (columns_per_device.front().join_columns[0].num_elems - 1) *
667 auto& host_hll_buffer = host_hll_buffers[device_id];
668 allocator->copyFromDevice(&host_hll_buffer[0],
670 count_distinct_desc.bitmapPaddedSizeBytes());
673 for (
auto& child : approximate_distinct_device_threads) {
677 auto& result_hll_buffer = host_hll_buffers.front();
678 auto hll_result =
reinterpret_cast<int32_t*
>(&result_hll_buffer[0]);
679 for (
int device_id = 1; device_id <
device_count_; ++device_id) {
680 auto& host_hll_buffer = host_hll_buffers[device_id];
682 reinterpret_cast<int32_t*>(&host_hll_buffer[0]),
683 1 << count_distinct_desc.bitmap_sz_bits);
685 size_t emitted_keys_count = 0;
686 for (
auto& emitted_keys_count_device : emitted_keys_count_device_threads) {
687 emitted_keys_count += emitted_keys_count_device;
689 return std::make_pair(
hll_size(hll_result, count_distinct_desc.bitmap_sz_bits),
697 #define LL_CONTEXT executor_->cgen_state_->context_
698 #define LL_BUILDER executor_->cgen_state_->ir_builder_
699 #define LL_INT(v) executor_->cgen_state_->llInt(v)
700 #define LL_FP(v) executor_->cgen_state_->llFp(v)
701 #define ROW_FUNC executor_->cgen_state_->row_func_
704 llvm::Value* offset_ptr) {
706 CHECK(key_component_width == 4 || key_component_width == 8);
708 llvm::Value* key_buff_lv{
nullptr};
709 switch (key_component_width) {
723 const auto outer_col = inner_outer_pair.second;
724 const auto outer_col_ti = outer_col->get_type_info();
726 if (outer_col_ti.is_geometry()) {
734 const auto col_lvs = code_generator.
codegen(outer_col,
true, co);
735 CHECK_EQ(col_lvs.size(), size_t(1));
738 CHECK(outer_col_var);
740 const auto coords_cd =
executor_->getCatalog()->getMetadataForColumn(
741 outer_col_var->get_table_id(), outer_col_var->get_column_id() + 1);
744 const auto array_ptr =
executor_->cgen_state_->emitExternalCall(
746 llvm::Type::getInt8PtrTy(
executor_->cgen_state_->context_),
747 {col_lvs.front(), code_generator.
posArg(outer_col)});
748 CHECK(coords_cd->columnType.get_elem_type().get_type() ==
kTINYINT)
749 <<
"Only TINYINT coordinates columns are supported in geo overlaps "
753 code_generator.castArrayPointer(array_ptr, coords_cd->columnType.get_elem_type());
757 LL_BUILDER.CreateLoad(offset_ptr->getType()->getPointerElementType(),
759 "packed_bucket_offset");
760 const auto x_offset =
763 const auto y_offset_shifted =
765 const auto y_offset =
768 const auto x_bucket_offset =
770 const auto y_bucket_offset =
773 for (
size_t i = 0; i < 2; i++) {
774 const auto key_comp_dest_lv =
LL_BUILDER.CreateGEP(
775 key_buff_lv->getType()->getScalarType()->getPointerElementType(),
779 const auto funcName =
isProbeCompressed() ?
"get_bucket_key_for_range_compressed"
780 :
"get_bucket_key_for_range_double";
784 auto bucket_key =
executor_->cgen_state_->emitExternalCall(
789 auto bucket_key_shifted = i == 0
790 ?
LL_BUILDER.CreateAdd(x_bucket_offset, bucket_key)
791 :
LL_BUILDER.CreateAdd(y_bucket_offset, bucket_key);
795 LL_BUILDER.CreateStore(col_lv, key_comp_dest_lv);
798 LOG(
FATAL) <<
"Range join key currently only supported for geospatial types.";
806 llvm::Value* range_offset) {
808 CHECK(key_component_width == 4 || key_component_width == 8);
810 auto key_buff_lv =
codegenKey(co, range_offset);
814 const auto composite_dict_ptr_type =
815 llvm::Type::getIntNPtrTy(
LL_CONTEXT, key_component_width * 8);
817 const auto composite_key_dict =
818 hash_ptr->getType()->isPointerTy()
819 ?
LL_BUILDER.CreatePointerCast(hash_ptr, composite_dict_ptr_type)
820 :
LL_BUILDER.CreateIntToPtr(hash_ptr, composite_dict_ptr_type);
824 const auto funcName =
825 "get_composite_key_index_" +
std::to_string(key_component_width * 8);
827 const auto key =
executor_->cgen_state_->emitExternalCall(funcName,
830 LL_INT(key_component_count),
834 auto one_to_many_ptr = hash_ptr;
835 if (one_to_many_ptr->getType()->isPointerTy()) {
839 CHECK(one_to_many_ptr->getType()->isIntegerTy(64));
static std::vector< int > collectFragmentIds(const std::vector< Fragmenter_Namespace::FragmentInfo > &fragments)
const JoinType join_type_
int getInnerTableId() const noexceptoverride
virtual HashJoinMatchingSet codegenMatchingSet(const CompilationOptions &, const size_t)=0
llvm::Value * codegenKey(const CompilationOptions &co, llvm::Value *offset)
static llvm::Value * codegenHashTableLoad(const size_t table_idx, Executor *executor)
std::shared_ptr< HashTable > initHashTableOnCpuFromCache(QueryPlanHash key, CacheItemType item_type, DeviceIdentifier device_identifier)
static bool isInvalidHashTableCacheKey(const std::vector< QueryPlanHash > &cache_keys)
std::pair< const Analyzer::ColumnVar *, const Analyzer::Expr * > InnerOuter
HashType getHashType() const noexceptoverride
std::vector< ChunkKey > cache_key_chunks
T * transfer_flat_object_to_gpu(const T &object, DeviceAllocator &allocator)
size_t getEntryCount() const
void hll_unify(T1 *lhs, T2 *rhs, const size_t m)
llvm::Value * posArg(const Analyzer::Expr *) const
std::vector< std::shared_ptr< HashTable > > hash_tables_for_device_
void reifyWithLayout(const HashType layout) override
#define DEBUG_TIMER_NEW_THREAD(parent_thread_id)
CountDistinctImplType impl_type_
void putHashTableOnCpuToCache(QueryPlanHash key, CacheItemType item_type, std::shared_ptr< HashTable > hashtable_ptr, DeviceIdentifier device_identifier, size_t hashtable_building_time)
llvm::Type * get_int_type(const int width, llvm::LLVMContext &context)
size_t hll_size(const T *M, const size_t bitmap_sz_bits)
const Expr * get_left_operand() const
size_t calculateHashTableSize(size_t number_of_dimensions, size_t emitted_keys_count, size_t entry_count) const
const std::shared_ptr< Analyzer::BinOper > condition_
const std::vector< JoinColumnTypeInfo > join_column_types
void approximate_distinct_tuples_on_device_range(uint8_t *hll_buffer, const uint32_t b, int32_t *row_counts_buffer, const RangeKeyHandler *key_handler, const size_t num_elems, const size_t block_size_x, const size_t grid_size_x)
future< Result > async(Fn &&fn, Args &&...args)
std::string toString() const override
std::unordered_map< size_t, HashTableBuildDag > HashTableBuildDagMap
std::shared_ptr< BaselineHashTable > initHashTableOnCpu(const std::vector< JoinColumn > &join_columns, const std::vector< JoinColumnTypeInfo > &join_column_types, const std::vector< JoinBucketInfo > &join_bucket_info, const HashType layout, const size_t entry_count, const size_t emitted_keys_count)
QueryPlanHash getAlternativeCacheKey(AlternativeCacheKeyForOverlapsHashJoin &info)
std::pair< size_t, size_t > approximateTupleCount(const std::vector< double > &inverse_bucket_sizes_for_dimension, std::vector< ColumnsForDevice > &columns_per_device, const size_t chosen_max_hashtable_size, const double chosen_bucket_threshold) override
const std::vector< InputTableInfo > & query_infos_
std::unordered_map< int, const RelAlgNode * > TableIdToNodeMap
std::vector< Fragmenter_Namespace::FragmentInfo > only_shards_for_device(const std::vector< Fragmenter_Namespace::FragmentInfo > &fragments, const int device_id, const int device_count)
static std::shared_ptr< RangeJoinHashTable > getInstance(const std::shared_ptr< Analyzer::BinOper > condition, const Analyzer::RangeOper *range_expr, const std::vector< InputTableInfo > &query_infos, const Data_Namespace::MemoryLevel memory_level, const JoinType join_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)
HashTableBuildDagMap hashtable_build_dag_map_
int initHashTableOnGpu(KEY_HANDLER *key_handler, const std::vector< JoinColumn > &join_columns, const HashType layout, const JoinType join_type, const size_t key_component_width, const size_t key_component_count, const size_t keyspace_entry_count, const size_t emitted_keys_count, const int device_id, const Executor *executor)
std::pair< size_t, size_t > computeRangeHashTableCounts(const size_t shard_count, std::vector< ColumnsForDevice > &columns_per_device)
std::vector< QueryPlanHash > hashtable_cache_key_
virtual int getInnerTableId() const noexcept=0
HashJoinMatchingSet codegenMatchingSetWithOffset(const CompilationOptions &, const size_t, llvm::Value *)
const double bucket_threshold_
const Expr * get_right_operand() const
static void checkHashJoinReplicationConstraint(const int table_id, const size_t shard_count, const Executor *executor)
void setOverlapsHashtableMetaInfo(size_t max_table_size_bytes, double bucket_threshold, std::vector< double > &bucket_sizes)
std::unordered_map< int, std::unordered_map< int, std::shared_ptr< const ColumnarResults >>> ColumnCacheMap
const InputTableInfo & get_inner_query_info(const int inner_table_id, const std::vector< InputTableInfo > &query_infos)
std::vector< llvm::Value * > codegen(const Analyzer::Expr *, const bool fetch_columns, const CompilationOptions &)
std::vector< double > inverse_bucket_sizes_for_dimension_
std::optional< HashType > layout_override_
std::pair< std::vector< const int32_t * >, std::vector< int32_t >> StrProxyTranslationMapsPtrsAndOffsets
bool isProbeCompressed() const
std::unique_ptr< BaselineHashTable > getHashTable()
static std::string getHashTypeString(HashType ht) noexcept
void setInverseBucketSizeInfo(const std::vector< double > &inverse_bucket_sizes, std::vector< ColumnsForDevice > &columns_per_device, const size_t device_count)
size_t get_entries_per_device(const size_t total_entries, const size_t shard_count, const size_t device_count, const Data_Namespace::MemoryLevel memory_level)
ColumnsForDevice fetchColumnsForDevice(const std::vector< Fragmenter_Namespace::FragmentInfo > &fragments, const int device_id, DeviceAllocator *dev_buff_owner)
size_t getKeyComponentCount() const
CUstream getQueryEngineCudaStreamForDevice(int device_num)
size_t offsetBufferOff() const noexceptoverride
bool isInnerColCompressed() const
size_t shardCount() const
void approximate_distinct_tuples_range(uint8_t *hll_buffer_all_cpus, std::vector< int32_t > &row_counts, const uint32_t b, const size_t padded_size_bytes, const std::vector< JoinColumn > &join_column_per_key, const std::vector< JoinColumnTypeInfo > &type_info_per_key, const std::vector< JoinBucketInfo > &join_buckets_per_key, const bool is_compressed, const int thread_count)
size_t getNumTuplesUpperBound() const
#define DEBUG_TIMER(name)
std::mutex cpu_hash_table_buff_mutex_
void reifyForDevice(const ColumnsForDevice &columns_for_device, const HashType layout, const size_t entry_count, const size_t emitted_keys_count, const int device_id, const logger::ThreadId parent_thread_id)
const Data_Namespace::MemoryLevel memory_level_
void generateCacheKey(const size_t max_hashtable_size, const double bucket_threshold, const std::vector< double > &bucket_sizes, std::vector< std::vector< Fragmenter_Namespace::FragmentInfo >> &fragments_per_device, int device_count)
size_t getComponentBufferSize() const noexceptoverride
static std::unique_ptr< HashtableRecycler > hash_table_cache_
std::vector< InnerOuter > inner_outer_pairs_
std::unordered_set< size_t > table_keys_
Data_Namespace::MemoryLevel effective_memory_level_
T * transfer_vector_of_flat_objects_to_gpu(const std::vector< T > &vec, DeviceAllocator &allocator)
static size_t getShardCountForCondition(const Analyzer::BinOper *condition, const Executor *executor, const std::vector< InnerOuter > &inner_outer_pairs)
Data_Namespace::MemoryLevel getEffectiveMemoryLevel(const std::vector< InnerOuter > &inner_outer_pairs) const
std::vector< JoinBucketInfo > join_buckets
const Analyzer::RangeOper * range_expr_
static constexpr DeviceIdentifier CPU_DEVICE_IDENTIFIER
static HashtableAccessPathInfo getHashtableAccessPathInfo(const std::vector< InnerOuter > &inner_outer_pairs, const std::vector< InnerOuterStringOpInfos > &inner_outer_string_op_infos_pairs, const SQLOps op_type, const JoinType join_type, const HashTableBuildDagMap &hashtable_build_dag_map, int device_count, int shard_count, const std::vector< std::vector< Fragmenter_Namespace::FragmentInfo >> &frags_for_device, Executor *executor)
CompositeKeyInfo composite_key_info_
size_t getKeyComponentWidth() const
const std::vector< JoinColumn > join_columns
static bool layoutRequiresAdditionalBuffers(HashType layout) noexcept
const size_t max_hashtable_size_
static CompositeKeyInfo getCompositeKeyInfo(const std::vector< InnerOuter > &inner_outer_pairs, const Executor *executor, const std::vector< InnerOuterStringOpInfos > &inner_outer_string_op_infos_pairs={})