#include <ResultSetStorage.h>

Collaboration diagram for ResultSetStorage:

Public Member Functions
void	reduce (const ResultSetStorage &that, const std::vector< std::string > &serialized_varlen_buffer, const ReductionCode &reduction_code, const size_t executor_id) const

void	rewriteAggregateBufferOffsets (const std::vector< std::string > &serialized_varlen_buffer) const

int8_t *	getUnderlyingBuffer () const

size_t	getEntryCount () const

template<class KeyType >
void	moveEntriesToBuffer (int8_t *new_buff, const size_t new_entry_count) const

template<class KeyType >
void	moveOneEntryToBuffer (const size_t entry_index, int64_t new_buff_i64, const size_t new_entry_count, const size_t key_count, const size_t row_qw_count, const int64_t src_buff, const size_t key_byte_width) const

void	updateEntryCount (const size_t new_entry_count)

void	reduceOneApproxQuantileSlot (int8_t this_ptr1, const int8_t that_ptr1, const size_t target_logical_idx, const ResultSetStorage &that) const

Static Public Member Functions
static bool	reduceSingleRow (const int8_t *row_ptr, const int8_t warp_count, const bool is_columnar, const bool replace_bitmap_ptr_with_bitmap_sz, std::vector< int64_t > &agg_vals, const QueryMemoryDescriptor &query_mem_desc, const std::vector< TargetInfo > &targets, const std::vector< int64_t > &agg_init_vals)

Private Member Functions
	ResultSetStorage (const std::vector< TargetInfo > &targets, const QueryMemoryDescriptor &query_mem_desc, int8_t *buff, const bool buff_is_provided)

void	reduceEntriesNoCollisionsColWise (int8_t this_buff, const int8_t that_buff, const ResultSetStorage &that, const size_t start_index, const size_t end_index, const std::vector< std::string > &serialized_varlen_buffer, const size_t executor_id) const

void	copyKeyColWise (const size_t entry_idx, int8_t this_buff, const int8_t that_buff) const

bool	isEmptyEntry (const size_t entry_idx, const int8_t *buff) const

bool	isEmptyEntry (const size_t entry_idx) const

bool	isEmptyEntryColumnar (const size_t entry_idx, const int8_t *buff) const

void	reduceOneEntryBaseline (int8_t this_buff, const int8_t that_buff, const size_t i, const size_t that_entry_count, const ResultSetStorage &that) const

void	reduceOneEntrySlotsBaseline (int64_t this_entry_slots, const int64_t that_buff, const size_t that_entry_idx, const size_t that_entry_count, const ResultSetStorage &that) const

void	initializeBaselineValueSlots (int64_t *this_entry_slots) const

void	reduceOneSlotBaseline (int64_t this_buff, const size_t this_slot, const int64_t that_buff, const size_t that_entry_count, const size_t that_slot, const TargetInfo &target_info, const size_t target_logical_idx, const size_t target_slot_idx, const size_t init_agg_val_idx, const ResultSetStorage &that) const

ALWAYS_INLINE void	reduceOneSlotSingleValue (int8_t this_ptr1, const TargetInfo &target_info, const size_t target_slot_idx, const size_t init_agg_val_idx, const int8_t that_ptr1) const

ALWAYS_INLINE void	reduceOneSlot (int8_t this_ptr1, int8_t this_ptr2, const int8_t that_ptr1, const int8_t that_ptr2, const TargetInfo &target_info, const size_t target_logical_idx, const size_t target_slot_idx, const size_t init_agg_val_idx, const ResultSetStorage &that, const size_t first_slot_idx_for_target, const std::vector< std::string > &serialized_varlen_buffer) const

void	reduceOneCountDistinctSlot (int8_t this_ptr1, const int8_t that_ptr1, const size_t target_logical_idx, const ResultSetStorage &that) const

void	fillOneEntryRowWise (const std::vector< int64_t > &entry)

void	fillOneEntryColWise (const std::vector< int64_t > &entry)

void	initializeRowWise () const

void	initializeColWise () const

const VarlenOutputInfo *	getVarlenOutputInfo () const

void	addCountDistinctSetPointerMapping (const int64_t remote_ptr, const int64_t ptr)

int64_t	mappedPtr (const int64_t) const

size_t	binSearchRowCount () const

Private Attributes
const std::vector< TargetInfo >	targets_

QueryMemoryDescriptor	query_mem_desc_

int8_t *	buff_

const bool	buff_is_provided_

std::vector< int64_t >	target_init_vals_

std::unordered_map< int64_t, int64_t >	count_distinct_sets_mapping_

std::shared_ptr< VarlenOutputInfo >	varlen_output_info_

Friends
class	ResultSet

class	ResultSetManager

Detailed Description

Definition at line 96 of file ResultSetStorage.h.

Constructor & Destructor Documentation

ResultSetStorage::ResultSetStorage	(	const std::vector< TargetInfo > &	targets,
		const QueryMemoryDescriptor &	query_mem_desc,
		int8_t *	buff,
		const bool	buff_is_provided
	)

private

Definition at line 53 of file ResultSetStorage.cpp.

     : targets_(targets)
     , query_mem_desc_(query_mem_desc)
     , buff_(buff)
     , buff_is_provided_(buff_is_provided)
     , target_init_vals_(result_set::initialize_target_values_for_storage(targets)) {}

Member Function Documentation

void ResultSetStorage::addCountDistinctSetPointerMapping	(	const int64_t	remote_ptr,
		const int64_t	ptr
	)

private

Definition at line 67 of file ResultSetStorage.cpp.

References CHECK, and count_distinct_sets_mapping_.

                                                                             {
   const auto it_ok = count_distinct_sets_mapping_.emplace(remote_ptr, ptr);
   CHECK(it_ok.second);
 }

size_t ResultSetStorage::binSearchRowCount ( ) const

private

Definition at line 2575 of file ResultSetIteration.cpp.

References CHECK, CHECK_EQ, QueryMemoryDescriptor::didOutputColumnar(), EMPTY_KEY_64, QueryMemoryDescriptor::getEffectiveKeyWidth(), QueryMemoryDescriptor::getEntryCount(), QueryMemoryDescriptor::getQueryDescriptionType(), anonymous_namespace{ResultSetIteration.cpp}::make_bin_search(), heavyai::Projection, ResultSet::query_mem_desc_, and row_ptr_rowwise().

                                                  {
   // Note that table function result sets should never use this path as the row count
   // can be known statically (as the output buffers do not contain empty entries)
   CHECK(query_mem_desc_.getQueryDescriptionType() == QueryDescriptionType::Projection);
   CHECK_EQ(query_mem_desc_.getEffectiveKeyWidth(), size_t(8));
 
   if (!query_mem_desc_.getEntryCount()) {
     return 0;
   }
 
   if (query_mem_desc_.didOutputColumnar()) {
     return make_bin_search(0, query_mem_desc_.getEntryCount(), [this](size_t idx) {
       return reinterpret_cast<const int64_t*>(buff_)[idx] == EMPTY_KEY_64;
     });
   } else {
     return make_bin_search(0, query_mem_desc_.getEntryCount(), [this](size_t idx) {
       const auto keys_ptr = row_ptr_rowwise(buff_, query_mem_desc_, idx);
       return *reinterpret_cast<const int64_t*>(keys_ptr) == EMPTY_KEY_64;
     });
   }
 }

Here is the call graph for this function:

void ResultSetStorage::copyKeyColWise	(	const size_t	entry_idx,
		int8_t *	this_buff,
		const int8_t *	that_buff
	)		const

private

Definition at line 505 of file ResultSetReduction.cpp.

References CHECK, QueryMemoryDescriptor::didOutputColumnar(), QueryMemoryDescriptor::getGroupbyColCount(), QueryMemoryDescriptor::getPrependedGroupColOffInBytes(), QueryMemoryDescriptor::groupColWidth(), and query_mem_desc_.

Referenced by reduceEntriesNoCollisionsColWise().

                                                                      {
   CHECK(query_mem_desc_.didOutputColumnar());
   for (size_t group_idx = 0; group_idx < query_mem_desc_.getGroupbyColCount();
        group_idx++) {
     // if the column corresponds to a group key
     const auto column_offset_bytes =
         query_mem_desc_.getPrependedGroupColOffInBytes(group_idx);
     auto lhs_key_ptr = this_buff + column_offset_bytes;
     auto rhs_key_ptr = that_buff + column_offset_bytes;
     switch (query_mem_desc_.groupColWidth(group_idx)) {
       case 8:
         *(reinterpret_cast<int64_t*>(lhs_key_ptr) + entry_idx) =
             *(reinterpret_cast<const int64_t*>(rhs_key_ptr) + entry_idx);
         break;
       case 4:
         *(reinterpret_cast<int32_t*>(lhs_key_ptr) + entry_idx) =
             *(reinterpret_cast<const int32_t*>(rhs_key_ptr) + entry_idx);
         break;
       case 2:
         *(reinterpret_cast<int16_t*>(lhs_key_ptr) + entry_idx) =
             *(reinterpret_cast<const int16_t*>(rhs_key_ptr) + entry_idx);
         break;
       case 1:
         *(reinterpret_cast<int8_t*>(lhs_key_ptr) + entry_idx) =
             *(reinterpret_cast<const int8_t*>(rhs_key_ptr) + entry_idx);
         break;
       default:
         CHECK(false);
         break;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetStorage::fillOneEntryColWise ( const std::vector< int64_t > & entry )

private

Definition at line 1195 of file ResultSetReduction.cpp.

References buff_, CHECK, CHECK_EQ, QueryMemoryDescriptor::didOutputColumnar(), QueryMemoryDescriptor::getBufferColSlotCount(), QueryMemoryDescriptor::getEntryCount(), QueryMemoryDescriptor::getGroupbyColCount(), key_offset_colwise(), query_mem_desc_, slot_offset_colwise(), and target_init_vals_.

                                                                           {
   CHECK(query_mem_desc_.didOutputColumnar());
   CHECK_EQ(size_t(1), query_mem_desc_.getEntryCount());
   const auto slot_count = query_mem_desc_.getBufferColSlotCount();
   const auto key_count = query_mem_desc_.getGroupbyColCount();
   CHECK_EQ(slot_count + key_count, entry.size());
   auto this_buff = reinterpret_cast<int64_t*>(buff_);
 
   for (size_t i = 0; i < key_count; i++) {
     const auto key_offset = key_offset_colwise(0, i, 1);
     this_buff[key_offset] = entry[i];
   }
 
   for (size_t i = 0; i < target_init_vals_.size(); i++) {
     const auto slot_offset = slot_offset_colwise(0, i, key_count, 1);
     this_buff[slot_offset] = entry[key_count + i];
   }
 }

Here is the call graph for this function:

void ResultSetStorage::fillOneEntryRowWise ( const std::vector< int64_t > & entry )

private

Definition at line 1142 of file ResultSetReduction.cpp.

References buff_, CHECK, CHECK_EQ, QueryMemoryDescriptor::didOutputColumnar(), QueryMemoryDescriptor::getBufferColSlotCount(), QueryMemoryDescriptor::getEffectiveKeyWidth(), QueryMemoryDescriptor::getEntryCount(), QueryMemoryDescriptor::getGroupbyColCount(), key_offset_rowwise(), query_mem_desc_, slot_offset_rowwise(), and target_init_vals_.

                                                                           {
   const auto slot_count = query_mem_desc_.getBufferColSlotCount();
   const auto key_count = query_mem_desc_.getGroupbyColCount();
   CHECK_EQ(slot_count + key_count, entry.size());
   auto this_buff = reinterpret_cast<int64_t*>(buff_);
   CHECK(!query_mem_desc_.didOutputColumnar());
   CHECK_EQ(size_t(1), query_mem_desc_.getEntryCount());
   const auto key_off = key_offset_rowwise(0, key_count, slot_count);
   CHECK_EQ(query_mem_desc_.getEffectiveKeyWidth(), sizeof(int64_t));
   for (size_t i = 0; i < key_count; ++i) {
     this_buff[key_off + i] = entry[i];
   }
   const auto first_slot_off = slot_offset_rowwise(0, 0, key_count, slot_count);
   for (size_t i = 0; i < target_init_vals_.size(); ++i) {
     this_buff[first_slot_off + i] = entry[key_count + i];
   }
 }

Here is the call graph for this function:

size_t ResultSetStorage::getEntryCount ( ) const

inline

Definition at line 114 of file ResultSetStorage.h.

References QueryMemoryDescriptor::getEntryCount(), and query_mem_desc_.

114 { return query_mem_desc_.getEntryCount(); }

QueryMemoryDescriptor::getEntryCount

size_t getEntryCount() const

Definition: QueryMemoryDescriptor.h:261

ResultSetStorage::query_mem_desc_

QueryMemoryDescriptor query_mem_desc_

Definition: ResultSetStorage.h:236

Here is the call graph for this function:

int8_t * ResultSetStorage::getUnderlyingBuffer ( ) const

Definition at line 63 of file ResultSetStorage.cpp.

References buff_.

Referenced by anonymous_namespace{Execute.cpp}::permute_storage_columnar(), and anonymous_namespace{Execute.cpp}::permute_storage_row_wise().

                                                     {
   return buff_;
 }

Here is the caller graph for this function:

const VarlenOutputInfo* ResultSetStorage::getVarlenOutputInfo ( ) const

inlineprivate

Definition at line 223 of file ResultSetStorage.h.

References varlen_output_info_.

                                                       {
     return varlen_output_info_.get();
   }

void ResultSetStorage::initializeBaselineValueSlots ( int64_t * this_entry_slots ) const

private

Definition at line 1234 of file ResultSetReduction.cpp.

References CHECK, QueryMemoryDescriptor::didOutputColumnar(), QueryMemoryDescriptor::getEntryCount(), query_mem_desc_, and target_init_vals_.

                                                                               {
   CHECK(entry_slots);
   if (query_mem_desc_.didOutputColumnar()) {
     size_t slot_off = 0;
     for (size_t j = 0; j < target_init_vals_.size(); ++j) {
       entry_slots[slot_off] = target_init_vals_[j];
       slot_off += query_mem_desc_.getEntryCount();
     }
   } else {
     for (size_t j = 0; j < target_init_vals_.size(); ++j) {
       entry_slots[j] = target_init_vals_[j];
     }
   }
 }

Here is the call graph for this function:

void ResultSetStorage::initializeColWise ( ) const

private

Definition at line 1214 of file ResultSetReduction.cpp.

References buff_, CHECK, EMPTY_KEY_64, QueryMemoryDescriptor::getEntryCount(), QueryMemoryDescriptor::getGroupbyColCount(), QueryMemoryDescriptor::hasKeylessHash(), key_offset_colwise(), query_mem_desc_, slot_offset_colwise(), and target_init_vals_.

                                                {
   const auto key_count = query_mem_desc_.getGroupbyColCount();
   auto this_buff = reinterpret_cast<int64_t*>(buff_);
   CHECK(!query_mem_desc_.hasKeylessHash());
   for (size_t key_idx = 0; key_idx < key_count; ++key_idx) {
     const auto first_key_off =
         key_offset_colwise(0, key_idx, query_mem_desc_.getEntryCount());
     for (size_t i = 0; i < query_mem_desc_.getEntryCount(); ++i) {
       this_buff[first_key_off + i] = EMPTY_KEY_64;
     }
   }
   for (size_t target_idx = 0; target_idx < target_init_vals_.size(); ++target_idx) {
     const auto first_val_off =
         slot_offset_colwise(0, target_idx, key_count, query_mem_desc_.getEntryCount());
     for (size_t i = 0; i < query_mem_desc_.getEntryCount(); ++i) {
       this_buff[first_val_off + i] = target_init_vals_[target_idx];
     }
   }
 }

Here is the call graph for this function:

void ResultSetStorage::initializeRowWise ( ) const

private

Definition at line 1160 of file ResultSetReduction.cpp.

References align_to_int64(), buff_, CHECK, CHECK_EQ, anonymous_namespace{ResultSetReduction.cpp}::fill_empty_key_32(), anonymous_namespace{ResultSetReduction.cpp}::fill_empty_key_64(), get_key_bytes_rowwise(), get_row_bytes(), QueryMemoryDescriptor::getEffectiveKeyWidth(), QueryMemoryDescriptor::getEntryCount(), QueryMemoryDescriptor::getGroupbyColCount(), QueryMemoryDescriptor::hasKeylessHash(), query_mem_desc_, and target_init_vals_.

                                                {
   const auto key_count = query_mem_desc_.getGroupbyColCount();
   const auto row_size = get_row_bytes(query_mem_desc_);
   CHECK_EQ(row_size % 8, 0u);
   const auto key_bytes_with_padding =
       align_to_int64(get_key_bytes_rowwise(query_mem_desc_));
   CHECK(!query_mem_desc_.hasKeylessHash());
   switch (query_mem_desc_.getEffectiveKeyWidth()) {
     case 4: {
       for (size_t i = 0; i < query_mem_desc_.getEntryCount(); ++i) {
         auto row_ptr = buff_ + i * row_size;
         fill_empty_key_32(reinterpret_cast<int32_t*>(row_ptr), key_count);
         auto slot_ptr = reinterpret_cast<int64_t*>(row_ptr + key_bytes_with_padding);
         for (size_t j = 0; j < target_init_vals_.size(); ++j) {
           slot_ptr[j] = target_init_vals_[j];
         }
       }
       break;
     }
     case 8: {
       for (size_t i = 0; i < query_mem_desc_.getEntryCount(); ++i) {
         auto row_ptr = buff_ + i * row_size;
         fill_empty_key_64(reinterpret_cast<int64_t*>(row_ptr), key_count);
         auto slot_ptr = reinterpret_cast<int64_t*>(row_ptr + key_bytes_with_padding);
         for (size_t j = 0; j < target_init_vals_.size(); ++j) {
           slot_ptr[j] = target_init_vals_[j];
         }
       }
       break;
     }
     default:
       CHECK(false);
   }
 }

Here is the call graph for this function:

bool ResultSetStorage::isEmptyEntry	(	const size_t	entry_idx,
		const int8_t *	buff
	)		const

private

Definition at line 2457 of file ResultSetIteration.cpp.

References CHECK, CHECK_GE, CHECK_LT, QueryMemoryDescriptor::didOutputColumnar(), EMPTY_KEY_32, EMPTY_KEY_64, result_set::get_byteoff_of_slot(), QueryMemoryDescriptor::getEffectiveKeyWidth(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), QueryMemoryDescriptor::getQueryDescriptionType(), QueryMemoryDescriptor::getTargetIdxForKey(), heavyai::GroupByPerfectHash, QueryMemoryDescriptor::hasKeylessHash(), heavyai::NonGroupedAggregate, ResultSet::query_mem_desc_, read_int_from_buff(), and row_ptr_rowwise().

Referenced by reduceOneEntryBaseline(), and rewriteAggregateBufferOffsets().

                                                                                     {
   if (QueryDescriptionType::NonGroupedAggregate ==
       query_mem_desc_.getQueryDescriptionType()) {
     return false;
   }
   if (query_mem_desc_.didOutputColumnar()) {
     return isEmptyEntryColumnar(entry_idx, buff);
   }
   if (query_mem_desc_.hasKeylessHash()) {
     CHECK(query_mem_desc_.getQueryDescriptionType() ==
           QueryDescriptionType::GroupByPerfectHash);
     CHECK_GE(query_mem_desc_.getTargetIdxForKey(), 0);
     CHECK_LT(static_cast<size_t>(query_mem_desc_.getTargetIdxForKey()),
              target_init_vals_.size());
     const auto rowwise_target_ptr = row_ptr_rowwise(buff, query_mem_desc_, entry_idx);
     const auto target_slot_off = result_set::get_byteoff_of_slot(
         query_mem_desc_.getTargetIdxForKey(), query_mem_desc_);
     return read_int_from_buff(rowwise_target_ptr + target_slot_off,
                               query_mem_desc_.getPaddedSlotWidthBytes(
                                   query_mem_desc_.getTargetIdxForKey())) ==
            target_init_vals_[query_mem_desc_.getTargetIdxForKey()];
   } else {
     const auto keys_ptr = row_ptr_rowwise(buff, query_mem_desc_, entry_idx);
     switch (query_mem_desc_.getEffectiveKeyWidth()) {
       case 4:
         CHECK(QueryDescriptionType::GroupByPerfectHash !=
               query_mem_desc_.getQueryDescriptionType());
         return *reinterpret_cast<const int32_t*>(keys_ptr) == EMPTY_KEY_32;
       case 8:
         return *reinterpret_cast<const int64_t*>(keys_ptr) == EMPTY_KEY_64;
       default:
         CHECK(false);
         return true;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool ResultSetStorage::isEmptyEntry ( const size_t entry_idx ) const

private

Definition at line 2597 of file ResultSetIteration.cpp.

                                                                 {
   return isEmptyEntry(entry_idx, buff_);
 }

bool ResultSetStorage::isEmptyEntryColumnar	(	const size_t	entry_idx,
		const int8_t *	buff
	)		const

private

Definition at line 2498 of file ResultSetIteration.cpp.

Referenced by reduceEntriesNoCollisionsColWise().

                                                                       {
   CHECK(query_mem_desc_.didOutputColumnar());
   if (query_mem_desc_.getQueryDescriptionType() ==
       QueryDescriptionType::NonGroupedAggregate) {
     return false;
   }
   if (query_mem_desc_.getQueryDescriptionType() == QueryDescriptionType::TableFunction) {
     // For table functions the entry count should always be set to the actual output size
     // (i.e. there are not empty entries), so just assume value is non-empty
     CHECK_LT(entry_idx, getEntryCount());
     return false;
   }
   if (query_mem_desc_.hasKeylessHash()) {
     CHECK(query_mem_desc_.getQueryDescriptionType() ==
           QueryDescriptionType::GroupByPerfectHash);
     CHECK_GE(query_mem_desc_.getTargetIdxForKey(), 0);
     CHECK_LT(static_cast<size_t>(query_mem_desc_.getTargetIdxForKey()),
              target_init_vals_.size());
     const auto col_buff = advance_col_buff_to_slot(
         buff, query_mem_desc_, targets_, query_mem_desc_.getTargetIdxForKey(), false);
     const auto entry_buff =
         col_buff + entry_idx * query_mem_desc_.getPaddedSlotWidthBytes(
                                    query_mem_desc_.getTargetIdxForKey());
     return read_int_from_buff(entry_buff,
                               query_mem_desc_.getPaddedSlotWidthBytes(
                                   query_mem_desc_.getTargetIdxForKey())) ==
            target_init_vals_[query_mem_desc_.getTargetIdxForKey()];
   } else {
     // it's enough to find the first group key which is empty
     if (query_mem_desc_.getQueryDescriptionType() == QueryDescriptionType::Projection) {
       return reinterpret_cast<const int64_t*>(buff)[entry_idx] == EMPTY_KEY_64;
     } else {
       CHECK(query_mem_desc_.getGroupbyColCount() > 0);
       const auto target_buff = buff + query_mem_desc_.getPrependedGroupColOffInBytes(0);
       switch (query_mem_desc_.groupColWidth(0)) {
         case 8:
           return reinterpret_cast<const int64_t*>(target_buff)[entry_idx] == EMPTY_KEY_64;
         case 4:
           return reinterpret_cast<const int32_t*>(target_buff)[entry_idx] == EMPTY_KEY_32;
         case 2:
           return reinterpret_cast<const int16_t*>(target_buff)[entry_idx] == EMPTY_KEY_16;
         case 1:
           return reinterpret_cast<const int8_t*>(target_buff)[entry_idx] == EMPTY_KEY_8;
         default:
           CHECK(false);
       }
     }
     return false;
   }
   return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t ResultSetStorage::mappedPtr ( const int64_t remote_ptr ) const

private

Definition at line 73 of file ResultSetStorage.cpp.

References count_distinct_sets_mapping_.

                                                                   {
   const auto it = count_distinct_sets_mapping_.find(remote_ptr);
   // Due to the removal of completely zero bitmaps in a distributed transfer there will be
   // remote ptr that do not not exists. Return 0 if no pointer found
   if (it == count_distinct_sets_mapping_.end()) {
     return int64_t(0);
   }
   return it->second;
 }

template<class KeyType >

void ResultSetStorage::moveEntriesToBuffer	(	int8_t *	new_buff,
		const size_t	new_entry_count
	)		const

Definition at line 940 of file ResultSetReduction.cpp.

References threading_serial::async(), buff_, CHECK, CHECK_GT, cpu_threads(), anonymous_namespace{ResultSetReduction.cpp}::get_row_qw_count(), QueryMemoryDescriptor::getEffectiveKeyWidth(), QueryMemoryDescriptor::getEntryCount(), QueryMemoryDescriptor::getGroupbyColCount(), QueryMemoryDescriptor::getQueryDescriptionType(), heavyai::GroupByBaselineHash, QueryMemoryDescriptor::hasKeylessHash(), query_mem_desc_, and anonymous_namespace{ResultSetReduction.cpp}::use_multithreaded_reduction().

                                                                                {
   CHECK(!query_mem_desc_.hasKeylessHash());
   CHECK_GT(new_entry_count, query_mem_desc_.getEntryCount());
   auto new_buff_i64 = reinterpret_cast<int64_t*>(new_buff);
   const auto key_count = query_mem_desc_.getGroupbyColCount();
   CHECK(QueryDescriptionType::GroupByBaselineHash ==
         query_mem_desc_.getQueryDescriptionType());
   const auto src_buff = reinterpret_cast<const int64_t*>(buff_);
   const auto row_qw_count = get_row_qw_count(query_mem_desc_);
   const auto key_byte_width = query_mem_desc_.getEffectiveKeyWidth();
 
   if (use_multithreaded_reduction(query_mem_desc_.getEntryCount())) {
     const size_t thread_count = cpu_threads();
     std::vector<std::future<void>> move_threads;
 
     for (size_t thread_idx = 0; thread_idx < thread_count; ++thread_idx) {
       const auto thread_entry_count =
           (query_mem_desc_.getEntryCount() + thread_count - 1) / thread_count;
       const auto start_index = thread_idx * thread_entry_count;
       const auto end_index =
           std::min(start_index + thread_entry_count, query_mem_desc_.getEntryCount());
       move_threads.emplace_back(std::async(
           std::launch::async,
           [this,
            src_buff,
            new_buff_i64,
            new_entry_count,
            start_index,
            end_index,
            key_count,
            row_qw_count,
            key_byte_width] {
             for (size_t entry_idx = start_index; entry_idx < end_index; ++entry_idx) {
               moveOneEntryToBuffer<KeyType>(entry_idx,
                                             new_buff_i64,
                                             new_entry_count,
                                             key_count,
                                             row_qw_count,
                                             src_buff,
                                             key_byte_width);
             }
           }));
     }
     for (auto& move_thread : move_threads) {
       move_thread.wait();
     }
     for (auto& move_thread : move_threads) {
       move_thread.get();
     }
   } else {
     for (size_t entry_idx = 0; entry_idx < query_mem_desc_.getEntryCount(); ++entry_idx) {
       moveOneEntryToBuffer<KeyType>(entry_idx,
                                     new_buff_i64,
                                     new_entry_count,
                                     key_count,
                                     row_qw_count,
                                     src_buff,
                                     key_byte_width);
     }
   }
 }

Here is the call graph for this function:

template<class KeyType >

void ResultSetStorage::moveOneEntryToBuffer	(	const size_t	entry_index,
		int64_t *	new_buff_i64,
		const size_t	new_entry_count,
		const size_t	key_count,
		const size_t	row_qw_count,
		const int64_t *	src_buff,
		const size_t	key_byte_width
	)		const

Definition at line 1004 of file ResultSetReduction.cpp.

References CHECK, QueryMemoryDescriptor::didOutputColumnar(), anonymous_namespace{ResultSetReduction.cpp}::fill_slots(), get_group_value(), get_group_value_columnar(), QueryMemoryDescriptor::getEntryCount(), key_offset_colwise(), anonymous_namespace{ResultSetReduction.cpp}::make_key(), and query_mem_desc_.

                                                                                {
   const auto key_off =
       query_mem_desc_.didOutputColumnar()
           ? key_offset_colwise(entry_index, 0, query_mem_desc_.getEntryCount())
           : row_qw_count * entry_index;
   const auto key_ptr = reinterpret_cast<const KeyType*>(&src_buff[key_off]);
   if (*key_ptr == get_empty_key<KeyType>()) {
     return;
   }
   int64_t* new_entries_ptr{nullptr};
   if (query_mem_desc_.didOutputColumnar()) {
     const auto key =
         make_key(&src_buff[key_off], query_mem_desc_.getEntryCount(), key_count);
     new_entries_ptr =
         get_group_value_columnar(new_buff_i64, new_entry_count, &key[0], key_count);
   } else {
     new_entries_ptr = get_group_value(new_buff_i64,
                                       new_entry_count,
                                       &src_buff[key_off],
                                       key_count,
                                       key_byte_width,
                                       row_qw_count);
   }
   CHECK(new_entries_ptr);
   fill_slots(new_entries_ptr,
              new_entry_count,
              src_buff,
              entry_index,
              query_mem_desc_.getEntryCount(),
              query_mem_desc_);
 }

Here is the call graph for this function:

void ResultSetStorage::reduce	(	const ResultSetStorage &	that,
		const std::vector< std::string > &	serialized_varlen_buffer,
		const ReductionCode &	reduction_code,
		const size_t	executor_id
	)		const

Definition at line 202 of file ResultSetReduction.cpp.

References threading_serial::async(), buff_, CHECK, CHECK_EQ, CHECK_GE, CHECK_GT, cpu_threads(), QueryMemoryDescriptor::didOutputColumnar(), QueryMemoryDescriptor::getEntryCount(), QueryMemoryDescriptor::getQueryDescriptionType(), heavyai::GroupByBaselineHash, heavyai::GroupByPerfectHash, ReductionCode::ir_reduce_loop, heavyai::NonGroupedAggregate, query_mem_desc_, reduceOneEntryBaseline(), anonymous_namespace{ResultSetReduction.cpp}::run_reduction_code(), and anonymous_namespace{ResultSetReduction.cpp}::use_multithreaded_reduction().

Referenced by reduceOneSlotSingleValue().

                                                               {
   auto entry_count = query_mem_desc_.getEntryCount();
   CHECK_GT(entry_count, size_t(0));
   if (query_mem_desc_.didOutputColumnar()) {
     CHECK(query_mem_desc_.getQueryDescriptionType() ==
               QueryDescriptionType::GroupByPerfectHash ||
           query_mem_desc_.getQueryDescriptionType() ==
               QueryDescriptionType::GroupByBaselineHash ||
           query_mem_desc_.getQueryDescriptionType() ==
               QueryDescriptionType::NonGroupedAggregate);
   }
   const auto that_entry_count = that.query_mem_desc_.getEntryCount();
   switch (query_mem_desc_.getQueryDescriptionType()) {
     case QueryDescriptionType::GroupByBaselineHash:
       CHECK_GE(entry_count, that_entry_count);
       break;
     default:
       CHECK_EQ(entry_count, that_entry_count);
   }
   auto this_buff = buff_;
   CHECK(this_buff);
   auto that_buff = that.buff_;
   CHECK(that_buff);
   if (query_mem_desc_.getQueryDescriptionType() ==
       QueryDescriptionType::GroupByBaselineHash) {
     if (!serialized_varlen_buffer.empty()) {
       throw std::runtime_error(
           "Projection of variable length targets with baseline hash group by is not yet "
           "supported in Distributed mode");
     }
     if (use_multithreaded_reduction(that_entry_count)) {
       const size_t thread_count = cpu_threads();
       std::vector<std::future<void>> reduction_threads;
       for (size_t thread_idx = 0; thread_idx < thread_count; ++thread_idx) {
         const auto thread_entry_count =
             (that_entry_count + thread_count - 1) / thread_count;
         const auto start_index = thread_idx * thread_entry_count;
         const auto end_index =
             std::min(start_index + thread_entry_count, that_entry_count);
         reduction_threads.emplace_back(std::async(
             std::launch::async,
             [this,
              this_buff,
              that_buff,
              start_index,
              end_index,
              that_entry_count,
              executor_id,
              &reduction_code,
              &that] {
               if (reduction_code.ir_reduce_loop) {
                 run_reduction_code(executor_id,
                                    reduction_code,
                                    this_buff,
                                    that_buff,
                                    start_index,
                                    end_index,
                                    that_entry_count,
                                    &query_mem_desc_,
                                    &that.query_mem_desc_,
                                    nullptr);
               } else {
                 for (size_t entry_idx = start_index; entry_idx < end_index; ++entry_idx) {
                   reduceOneEntryBaseline(
                       this_buff, that_buff, entry_idx, that_entry_count, that);
                 }
               }
             }));
       }
       for (auto& reduction_thread : reduction_threads) {
         reduction_thread.wait();
       }
       for (auto& reduction_thread : reduction_threads) {
         reduction_thread.get();
       }
     } else {
       if (reduction_code.ir_reduce_loop) {
         run_reduction_code(executor_id,
                            reduction_code,
                            this_buff,
                            that_buff,
                            0,
                            that_entry_count,
                            that_entry_count,
                            &query_mem_desc_,
                            &that.query_mem_desc_,
                            nullptr);
       } else {
         for (size_t i = 0; i < that_entry_count; ++i) {
           reduceOneEntryBaseline(this_buff, that_buff, i, that_entry_count, that);
         }
       }
     }
     return;
   }
   if (use_multithreaded_reduction(entry_count)) {
     const size_t thread_count = cpu_threads();
     std::vector<std::future<void>> reduction_threads;
     for (size_t thread_idx = 0; thread_idx < thread_count; ++thread_idx) {
       const auto thread_entry_count = (entry_count + thread_count - 1) / thread_count;
       const auto start_index = thread_idx * thread_entry_count;
       const auto end_index = std::min(start_index + thread_entry_count, entry_count);
       if (query_mem_desc_.didOutputColumnar()) {
         reduction_threads.emplace_back(std::async(std::launch::async,
                                                   [this,
                                                    this_buff,
                                                    that_buff,
                                                    start_index,
                                                    end_index,
                                                    &that,
                                                    &serialized_varlen_buffer,
                                                    &executor_id] {
                                                     reduceEntriesNoCollisionsColWise(
                                                         this_buff,
                                                         that_buff,
                                                         that,
                                                         start_index,
                                                         end_index,
                                                         serialized_varlen_buffer,
                                                         executor_id);
                                                   }));
       } else {
         reduction_threads.emplace_back(std::async(std::launch::async,
                                                   [this,
                                                    this_buff,
                                                    that_buff,
                                                    start_index,
                                                    end_index,
                                                    that_entry_count,
                                                    executor_id,
                                                    &reduction_code,
                                                    &that,
                                                    &serialized_varlen_buffer] {
                                                     CHECK(reduction_code.ir_reduce_loop);
                                                     run_reduction_code(
                                                         executor_id,
                                                         reduction_code,
                                                         this_buff,
                                                         that_buff,
                                                         start_index,
                                                         end_index,
                                                         that_entry_count,
                                                         &query_mem_desc_,
                                                         &that.query_mem_desc_,
                                                         &serialized_varlen_buffer);
                                                   }));
       }
     }
     for (auto& reduction_thread : reduction_threads) {
       reduction_thread.wait();
     }
     for (auto& reduction_thread : reduction_threads) {
       reduction_thread.get();
     }
   } else {
     if (query_mem_desc_.didOutputColumnar()) {
       reduceEntriesNoCollisionsColWise(this_buff,
                                        that_buff,
                                        that,
                                        0,
                                        query_mem_desc_.getEntryCount(),
                                        serialized_varlen_buffer,
                                        executor_id);
     } else {
       CHECK(reduction_code.ir_reduce_loop);
       run_reduction_code(executor_id,
                          reduction_code,
                          this_buff,
                          that_buff,
                          0,
                          entry_count,
                          that_entry_count,
                          &query_mem_desc_,
                          &that.query_mem_desc_,
                          &serialized_varlen_buffer);
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetStorage::reduceEntriesNoCollisionsColWise	(	int8_t *	this_buff,
		const int8_t *	that_buff,
		const ResultSetStorage &	that,
		const size_t	start_index,
		const size_t	end_index,
		const std::vector< std::string > &	serialized_varlen_buffer,
		const size_t	executor_id
	)		const

private

Definition at line 406 of file ResultSetReduction.cpp.

References advance_to_next_columnar_target_buff(), CHECK, anonymous_namespace{ResultSetReduction.cpp}::check_watchdog(), copyKeyColWise(), g_enable_dynamic_watchdog, g_enable_non_kernel_time_query_interrupt, get_cols_ptr(), QueryMemoryDescriptor::getColSlotContext(), Executor::getExecutor(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), QueryMemoryDescriptor::hasKeylessHash(), isEmptyEntryColumnar(), kAVG, kSAMPLE, LIKELY, query_mem_desc_, reduceOneSlot(), targets_, and UNLIKELY.

                                     {
   // TODO(adb / saman): Support column wise output when serializing distributed agg
   // functions
   CHECK(serialized_varlen_buffer.empty());
 
   const auto& col_slot_context = query_mem_desc_.getColSlotContext();
 
   auto this_crt_col_ptr = get_cols_ptr(this_buff, query_mem_desc_);
   auto that_crt_col_ptr = get_cols_ptr(that_buff, query_mem_desc_);
   auto executor = Executor::getExecutor(executor_id);
   CHECK(executor);
   for (size_t target_idx = 0; target_idx < targets_.size(); ++target_idx) {
     const auto& agg_info = targets_[target_idx];
     const auto& slots_for_col = col_slot_context.getSlotsForCol(target_idx);
 
     bool two_slot_target{false};
     if (agg_info.is_agg &&
         (agg_info.agg_kind == kAVG ||
          (agg_info.agg_kind == kSAMPLE && agg_info.sql_type.is_varlen()))) {
       // Note that this assumes if one of the slot pairs in a given target is an array,
       // all slot pairs are arrays. Currently this is true for all geo targets, but we
       // should better codify and store this information in the future
       two_slot_target = true;
     }
     if (UNLIKELY(g_enable_non_kernel_time_query_interrupt &&
                  executor->checkNonKernelTimeInterrupted())) {
       throw std::runtime_error(
           "Query execution was interrupted during result set reduction");
     }
     if (g_enable_dynamic_watchdog) {
       check_watchdog();
     }
     for (size_t target_slot_idx = slots_for_col.front();
          target_slot_idx < slots_for_col.back() + 1;
          target_slot_idx += 2) {
       const auto this_next_col_ptr = advance_to_next_columnar_target_buff(
           this_crt_col_ptr, query_mem_desc_, target_slot_idx);
       const auto that_next_col_ptr = advance_to_next_columnar_target_buff(
           that_crt_col_ptr, query_mem_desc_, target_slot_idx);
       for (size_t entry_idx = start_index; entry_idx < end_index; ++entry_idx) {
         if (isEmptyEntryColumnar(entry_idx, that_buff)) {
           continue;
         }
         if (LIKELY(!query_mem_desc_.hasKeylessHash())) {
           // copy the key from right hand side
           copyKeyColWise(entry_idx, this_buff, that_buff);
         }
         auto this_ptr1 =
             this_crt_col_ptr +
             entry_idx * query_mem_desc_.getPaddedSlotWidthBytes(target_slot_idx);
         auto that_ptr1 =
             that_crt_col_ptr +
             entry_idx * query_mem_desc_.getPaddedSlotWidthBytes(target_slot_idx);
         int8_t* this_ptr2{nullptr};
         const int8_t* that_ptr2{nullptr};
         if (UNLIKELY(two_slot_target)) {
           this_ptr2 =
               this_next_col_ptr +
               entry_idx * query_mem_desc_.getPaddedSlotWidthBytes(target_slot_idx + 1);
           that_ptr2 =
               that_next_col_ptr +
               entry_idx * query_mem_desc_.getPaddedSlotWidthBytes(target_slot_idx + 1);
         }
         reduceOneSlot(this_ptr1,
                       this_ptr2,
                       that_ptr1,
                       that_ptr2,
                       agg_info,
                       target_idx,
                       target_slot_idx,
                       target_slot_idx,
                       that,
                       slots_for_col.front(),
                       serialized_varlen_buffer);
       }
 
       this_crt_col_ptr = this_next_col_ptr;
       that_crt_col_ptr = that_next_col_ptr;
       if (UNLIKELY(two_slot_target)) {
         this_crt_col_ptr = advance_to_next_columnar_target_buff(
             this_crt_col_ptr, query_mem_desc_, target_slot_idx + 1);
         that_crt_col_ptr = advance_to_next_columnar_target_buff(
             that_crt_col_ptr, query_mem_desc_, target_slot_idx + 1);
       }
     }
   }
 }

Here is the call graph for this function:

void ResultSetStorage::reduceOneApproxQuantileSlot	(	int8_t *	this_ptr1,
		const int8_t *	that_ptr1,
		const size_t	target_logical_idx,
		const ResultSetStorage &	that
	)		const

Definition at line 1600 of file ResultSetReduction.cpp.

References CHECK, CHECK_LT, QueryMemoryDescriptor::getCountDistinctDescriptorsSize(), and query_mem_desc_.

Referenced by reduceOneSlot().

                                                                                        {
   CHECK_LT(target_logical_idx, query_mem_desc_.getCountDistinctDescriptorsSize());
   static_assert(sizeof(int64_t) == sizeof(quantile::TDigest*));
   auto* incoming = *reinterpret_cast<quantile::TDigest* const*>(that_ptr1);
   CHECK(incoming) << "this_ptr1=" << (void*)this_ptr1
                   << ", that_ptr1=" << (void const*)that_ptr1
                   << ", target_logical_idx=" << target_logical_idx;
   if (incoming->centroids().capacity()) {
     auto* accumulator = *reinterpret_cast<quantile::TDigest**>(this_ptr1);
     CHECK(accumulator) << "this_ptr1=" << (void*)this_ptr1
                        << ", that_ptr1=" << (void const*)that_ptr1
                        << ", target_logical_idx=" << target_logical_idx;
     accumulator->allocate();
     accumulator->mergeTDigest(*incoming);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetStorage::reduceOneCountDistinctSlot	(	int8_t *	this_ptr1,
		const int8_t *	that_ptr1,
		const size_t	target_logical_idx,
		const ResultSetStorage &	that
	)		const

private

Definition at line 1620 of file ResultSetReduction.cpp.

References CHECK, CHECK_LT, count_distinct_set_union(), QueryMemoryDescriptor::getCountDistinctDescriptor(), QueryMemoryDescriptor::getCountDistinctDescriptorsSize(), Invalid, and query_mem_desc_.

Referenced by reduceOneSlot().

                                                                                       {
   CHECK_LT(target_logical_idx, query_mem_desc_.getCountDistinctDescriptorsSize());
   const auto& old_count_distinct_desc =
       query_mem_desc_.getCountDistinctDescriptor(target_logical_idx);
   CHECK(old_count_distinct_desc.impl_type_ != CountDistinctImplType::Invalid);
   const auto& new_count_distinct_desc =
       that.query_mem_desc_.getCountDistinctDescriptor(target_logical_idx);
   CHECK(old_count_distinct_desc.impl_type_ == new_count_distinct_desc.impl_type_);
   CHECK(this_ptr1 && that_ptr1);
   auto old_set_ptr = reinterpret_cast<const int64_t*>(this_ptr1);
   auto new_set_ptr = reinterpret_cast<const int64_t*>(that_ptr1);
   count_distinct_set_union(
       *new_set_ptr, *old_set_ptr, new_count_distinct_desc, old_count_distinct_desc);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetStorage::reduceOneEntryBaseline	(	int8_t *	this_buff,
		const int8_t *	that_buff,
		const size_t	i,
		const size_t	that_entry_count,
		const ResultSetStorage &	that
	)		const

private

Definition at line 829 of file ResultSetReduction.cpp.

References CHECK, anonymous_namespace{ResultSetReduction.cpp}::check_watchdog_with_seed(), QueryMemoryDescriptor::didOutputColumnar(), anonymous_namespace{ResultSetReduction.cpp}::fill_slots(), g_enable_dynamic_watchdog, anonymous_namespace{ResultSetReduction.cpp}::get_group_value_columnar_reduction(), QueryMemoryDescriptor::getEntryCount(), QueryMemoryDescriptor::getGroupbyColCount(), QueryMemoryDescriptor::getQueryDescriptionType(), heavyai::GroupByBaselineHash, QueryMemoryDescriptor::hasKeylessHash(), isEmptyEntry(), key_offset_colwise(), anonymous_namespace{ResultSetReduction.cpp}::make_key(), query_mem_desc_, and reduceOneEntrySlotsBaseline().

Referenced by reduce().

                                                                                   {
   if (g_enable_dynamic_watchdog) {
     check_watchdog_with_seed(that_entry_idx);
   }
   const auto key_count = query_mem_desc_.getGroupbyColCount();
   CHECK(query_mem_desc_.getQueryDescriptionType() ==
         QueryDescriptionType::GroupByBaselineHash);
   CHECK(!query_mem_desc_.hasKeylessHash());
   CHECK(query_mem_desc_.didOutputColumnar());
   const auto key_off =
       key_offset_colwise(that_entry_idx, 0, query_mem_desc_.didOutputColumnar());
   if (isEmptyEntry(that_entry_idx, that_buff)) {
     return;
   }
   auto this_buff_i64 = reinterpret_cast<int64_t*>(this_buff);
   auto that_buff_i64 = reinterpret_cast<const int64_t*>(that_buff);
   const auto key = make_key(&that_buff_i64[key_off], that_entry_count, key_count);
   auto [this_entry_slots, empty_entry] = get_group_value_columnar_reduction(
       this_buff_i64, query_mem_desc_.getEntryCount(), &key[0], key_count);
   CHECK(this_entry_slots);
   if (empty_entry) {
     fill_slots(this_entry_slots,
                query_mem_desc_.getEntryCount(),
                that_buff_i64,
                that_entry_idx,
                that_entry_count,
                query_mem_desc_);
     return;
   }
   reduceOneEntrySlotsBaseline(
       this_entry_slots, that_buff_i64, that_entry_idx, that_entry_count, that);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetStorage::reduceOneEntrySlotsBaseline	(	int64_t *	this_entry_slots,
		const int64_t *	that_buff,
		const size_t	that_entry_idx,
		const size_t	that_entry_count,
		const ResultSetStorage &	that
	)		const

private

Definition at line 866 of file ResultSetReduction.cpp.

References advance_slot(), CHECK, QueryMemoryDescriptor::didOutputColumnar(), QueryMemoryDescriptor::getEntryCount(), QueryMemoryDescriptor::getGroupbyColCount(), QueryMemoryDescriptor::getTargetGroupbyIndex(), query_mem_desc_, reduceOneSlotBaseline(), slot_offset_colwise(), QueryMemoryDescriptor::targetGroupbyIndicesSize(), and targets_.

Referenced by reduceOneEntryBaseline().

                                                                                        {
   CHECK(query_mem_desc_.didOutputColumnar());
   const auto key_count = query_mem_desc_.getGroupbyColCount();
   size_t j = 0;
   size_t init_agg_val_idx = 0;
   for (size_t target_logical_idx = 0; target_logical_idx < targets_.size();
        ++target_logical_idx) {
     const auto& target_info = targets_[target_logical_idx];
     const auto that_slot_off = slot_offset_colwise(
         that_entry_idx, init_agg_val_idx, key_count, that_entry_count);
     const auto this_slot_off = init_agg_val_idx * query_mem_desc_.getEntryCount();
     reduceOneSlotBaseline(this_entry_slots,
                           this_slot_off,
                           that_buff,
                           that_entry_count,
                           that_slot_off,
                           target_info,
                           target_logical_idx,
                           j,
                           init_agg_val_idx,
                           that);
     if (query_mem_desc_.targetGroupbyIndicesSize() == 0) {
       init_agg_val_idx = advance_slot(init_agg_val_idx, target_info, false);
     } else {
       if (query_mem_desc_.getTargetGroupbyIndex(target_logical_idx) < 0) {
         init_agg_val_idx = advance_slot(init_agg_val_idx, target_info, false);
       }
     }
     j = advance_slot(j, target_info, false);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetStorage::reduceOneSlot	(	int8_t *	this_ptr1,
		int8_t *	this_ptr2,
		const int8_t *	that_ptr1,
		const int8_t *	that_ptr2,
		const TargetInfo &	target_info,
		const size_t	target_logical_idx,
		const size_t	target_slot_idx,
		const size_t	init_agg_val_idx,
		const ResultSetStorage &	that,
		const size_t	first_slot_idx_for_target,
		const std::vector< std::string > &	serialized_varlen_buffer
	)		const

private

Definition at line 1454 of file ResultSetReduction.cpp.

References TargetInfo::agg_kind, AGGREGATE_ONE_COUNT, AGGREGATE_ONE_NULLABLE_VALUE, AGGREGATE_ONE_NULLABLE_VALUE_SMALL, CHECK, CHECK_EQ, CHECK_LT, logger::FATAL, SQLTypeInfo::get_elem_type(), result_set::get_width_for_slot(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), QueryMemoryDescriptor::getTargetGroupbyIndex(), TargetInfo::is_agg, is_distinct_target(), SQLTypeInfo::is_geometry(), SQLTypeInfo::is_string(), SQLTypeInfo::is_varlen(), QueryMemoryDescriptor::isLogicalSizedColumnsAllowed(), kAPPROX_COUNT_DISTINCT, kAPPROX_QUANTILE, kAVG, kCOUNT, kCOUNT_IF, kMAX, kMIN, kSAMPLE, kSINGLE_VALUE, kSUM, kSUM_IF, LOG, query_mem_desc_, reduceOneApproxQuantileSlot(), reduceOneCountDistinctSlot(), reduceOneSlotSingleValue(), TargetInfo::sql_type, takes_float_argument(), target_init_vals_, QueryMemoryDescriptor::targetGroupbyIndicesSize(), toString(), and UNREACHABLE.

Referenced by reduceEntriesNoCollisionsColWise(), and reduceOneSlotBaseline().

                                                                 {
   if (query_mem_desc_.targetGroupbyIndicesSize() > 0) {
     if (query_mem_desc_.getTargetGroupbyIndex(target_logical_idx) >= 0) {
       return;
     }
   }
   CHECK_LT(init_agg_val_idx, target_init_vals_.size());
   const bool float_argument_input = takes_float_argument(target_info);
   const auto chosen_bytes = result_set::get_width_for_slot(
       target_slot_idx, float_argument_input, query_mem_desc_);
   int64_t init_val = target_init_vals_[init_agg_val_idx];  // skip_val for nullable types
 
   if (target_info.is_agg && target_info.agg_kind == kSINGLE_VALUE) {
     reduceOneSlotSingleValue(
         this_ptr1, target_info, target_logical_idx, init_agg_val_idx, that_ptr1);
   } else if (target_info.is_agg && target_info.agg_kind != kSAMPLE) {
     switch (target_info.agg_kind) {
       case kCOUNT:
       case kCOUNT_IF:
       case kAPPROX_COUNT_DISTINCT: {
         if (is_distinct_target(target_info)) {
           CHECK_EQ(static_cast<size_t>(chosen_bytes), sizeof(int64_t));
           reduceOneCountDistinctSlot(this_ptr1, that_ptr1, target_logical_idx, that);
           break;
         }
         CHECK_EQ(int64_t(0), init_val);
         AGGREGATE_ONE_COUNT(this_ptr1, that_ptr1, chosen_bytes);
         break;
       }
       case kAVG: {
         // Ignore float argument compaction for count component for fear of its overflow
         AGGREGATE_ONE_COUNT(this_ptr2,
                             that_ptr2,
                             query_mem_desc_.getPaddedSlotWidthBytes(target_slot_idx));
       }
       // fall thru
       case kSUM:
       case kSUM_IF: {
         AGGREGATE_ONE_NULLABLE_VALUE(
             sum, this_ptr1, that_ptr1, init_val, chosen_bytes, target_info);
         break;
       }
       case kMIN: {
         if (static_cast<size_t>(chosen_bytes) <= sizeof(int16_t)) {
           AGGREGATE_ONE_NULLABLE_VALUE_SMALL(
               min, this_ptr1, that_ptr1, init_val, chosen_bytes, target_info);
         } else {
           AGGREGATE_ONE_NULLABLE_VALUE(
               min, this_ptr1, that_ptr1, init_val, chosen_bytes, target_info);
         }
         break;
       }
       case kMAX: {
         if (static_cast<size_t>(chosen_bytes) <= sizeof(int16_t)) {
           AGGREGATE_ONE_NULLABLE_VALUE_SMALL(
               max, this_ptr1, that_ptr1, init_val, chosen_bytes, target_info);
         } else {
           AGGREGATE_ONE_NULLABLE_VALUE(
               max, this_ptr1, that_ptr1, init_val, chosen_bytes, target_info);
         }
         break;
       }
       case kAPPROX_QUANTILE:
         CHECK_EQ(static_cast<int8_t>(sizeof(int64_t)), chosen_bytes);
         reduceOneApproxQuantileSlot(this_ptr1, that_ptr1, target_logical_idx, that);
         break;
       default:
         UNREACHABLE() << toString(target_info.agg_kind);
     }
   } else {
     switch (chosen_bytes) {
       case 1: {
         CHECK(query_mem_desc_.isLogicalSizedColumnsAllowed());
         const auto rhs_proj_col = *reinterpret_cast<const int8_t*>(that_ptr1);
         if (rhs_proj_col != init_val) {
           *reinterpret_cast<int8_t*>(this_ptr1) = rhs_proj_col;
         }
         break;
       }
       case 2: {
         CHECK(query_mem_desc_.isLogicalSizedColumnsAllowed());
         const auto rhs_proj_col = *reinterpret_cast<const int16_t*>(that_ptr1);
         if (rhs_proj_col != init_val) {
           *reinterpret_cast<int16_t*>(this_ptr1) = rhs_proj_col;
         }
         break;
       }
       case 4: {
         CHECK(target_info.agg_kind != kSAMPLE ||
               query_mem_desc_.isLogicalSizedColumnsAllowed());
         const auto rhs_proj_col = *reinterpret_cast<const int32_t*>(that_ptr1);
         if (rhs_proj_col != init_val) {
           *reinterpret_cast<int32_t*>(this_ptr1) = rhs_proj_col;
         }
         break;
       }
       case 8: {
         auto rhs_proj_col = *reinterpret_cast<const int64_t*>(that_ptr1);
         if ((target_info.agg_kind == kSAMPLE && target_info.sql_type.is_varlen()) &&
             !serialized_varlen_buffer.empty()) {
           size_t length_to_elems{0};
           if (target_info.sql_type.is_geometry()) {
             // TODO: Assumes hard-coded sizes for geometry targets
             length_to_elems = target_slot_idx == first_slot_idx_for_target ? 1 : 4;
           } else {
             const auto& elem_ti = target_info.sql_type.get_elem_type();
             length_to_elems = target_info.sql_type.is_string() ? 1 : elem_ti.get_size();
           }
 
           CHECK_LT(static_cast<size_t>(rhs_proj_col), serialized_varlen_buffer.size());
           const auto& varlen_bytes_str = serialized_varlen_buffer[rhs_proj_col];
           const auto str_ptr = reinterpret_cast<const int8_t*>(varlen_bytes_str.c_str());
           *reinterpret_cast<int64_t*>(this_ptr1) =
               reinterpret_cast<const int64_t>(str_ptr);
           *reinterpret_cast<int64_t*>(this_ptr2) =
               static_cast<int64_t>(varlen_bytes_str.size() / length_to_elems);
         } else {
           if (rhs_proj_col != init_val) {
             *reinterpret_cast<int64_t*>(this_ptr1) = rhs_proj_col;
           }
           if ((target_info.agg_kind == kSAMPLE && target_info.sql_type.is_varlen())) {
             CHECK(this_ptr2 && that_ptr2);
             *reinterpret_cast<int64_t*>(this_ptr2) =
                 *reinterpret_cast<const int64_t*>(that_ptr2);
           }
         }
 
         break;
       }
       default:
         LOG(FATAL) << "Invalid slot width: " << chosen_bytes;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetStorage::reduceOneSlotBaseline	(	int64_t *	this_buff,
		const size_t	this_slot,
		const int64_t *	that_buff,
		const size_t	that_entry_count,
		const size_t	that_slot,
		const TargetInfo &	target_info,
		const size_t	target_logical_idx,
		const size_t	target_slot_idx,
		const size_t	init_agg_val_idx,
		const ResultSetStorage &	that
	)		const

private

Definition at line 902 of file ResultSetReduction.cpp.

References TargetInfo::agg_kind, CHECK, QueryMemoryDescriptor::didOutputColumnar(), QueryMemoryDescriptor::getEntryCount(), TargetInfo::is_agg, SQLTypeInfo::is_varlen(), kAVG, kSAMPLE, query_mem_desc_, reduceOneSlot(), and TargetInfo::sql_type.

Referenced by reduceOneEntrySlotsBaseline().

                                                                                  {
   CHECK(query_mem_desc_.didOutputColumnar());
   int8_t* this_ptr2{nullptr};
   const int8_t* that_ptr2{nullptr};
   if (target_info.is_agg &&
       (target_info.agg_kind == kAVG ||
        (target_info.agg_kind == kSAMPLE && target_info.sql_type.is_varlen()))) {
     const auto this_count_off = query_mem_desc_.getEntryCount();
     const auto that_count_off = that_entry_count;
     this_ptr2 = reinterpret_cast<int8_t*>(&this_buff[this_slot + this_count_off]);
     that_ptr2 = reinterpret_cast<const int8_t*>(&that_buff[that_slot + that_count_off]);
   }
   reduceOneSlot(reinterpret_cast<int8_t*>(&this_buff[this_slot]),
                 this_ptr2,
                 reinterpret_cast<const int8_t*>(&that_buff[that_slot]),
                 that_ptr2,
                 target_info,
                 target_logical_idx,
                 target_slot_idx,
                 init_agg_val_idx,
                 that,
                 target_slot_idx,  // dummy, for now
                 {});
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetStorage::reduceOneSlotSingleValue	(	int8_t *	this_ptr1,
		const TargetInfo &	target_info,
		const size_t	target_slot_idx,
		const size_t	init_agg_val_idx,
		const int8_t *	that_ptr1
	)		const

private

Definition at line 1406 of file ResultSetReduction.cpp.

References CHECK, logger::FATAL, result_set::get_width_for_slot(), SQLTypeInfo::is_varlen(), QueryMemoryDescriptor::isLogicalSizedColumnsAllowed(), LOG, query_mem_desc_, reduce(), TargetInfo::sql_type, takes_float_argument(), and target_init_vals_.

Referenced by reduceOneSlot().

                                                                                {
   const bool float_argument_input = takes_float_argument(target_info);
   const auto chosen_bytes = result_set::get_width_for_slot(
       target_slot_idx, float_argument_input, query_mem_desc_);
   auto init_val = target_init_vals_[init_agg_val_idx];
 
   auto reduce = [&](auto const& size_tag) {
     using CastTarget = std::decay_t<decltype(size_tag)>;
     const auto lhs_proj_col = *reinterpret_cast<const CastTarget*>(this_ptr1);
     const auto rhs_proj_col = *reinterpret_cast<const CastTarget*>(that_ptr1);
     if (rhs_proj_col == init_val) {
       // ignore
     } else if (lhs_proj_col == init_val) {
       *reinterpret_cast<CastTarget*>(this_ptr1) = rhs_proj_col;
     } else if (lhs_proj_col != rhs_proj_col) {
       throw std::runtime_error("Multiple distinct values encountered");
     }
   };
 
   switch (chosen_bytes) {
     case 1: {
       CHECK(query_mem_desc_.isLogicalSizedColumnsAllowed());
       reduce(int8_t());
       break;
     }
     case 2: {
       CHECK(query_mem_desc_.isLogicalSizedColumnsAllowed());
       reduce(int16_t());
       break;
     }
     case 4: {
       reduce(int32_t());
       break;
     }
     case 8: {
       CHECK(!target_info.sql_type.is_varlen());
       reduce(int64_t());
       break;
     }
     default:
       LOG(FATAL) << "Invalid slot width: " << chosen_bytes;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool ResultSetStorage::reduceSingleRow	(	const int8_t *	row_ptr,
		const int8_t	warp_count,
		const bool	is_columnar,
		const bool	replace_bitmap_ptr_with_bitmap_sz,
		std::vector< int64_t > &	agg_vals,
		const QueryMemoryDescriptor &	query_mem_desc,
		const std::vector< TargetInfo > &	targets,
		const std::vector< int64_t > &	agg_init_vals
	)

static

Definition at line 1638 of file ResultSetReduction.cpp.

Referenced by QueryExecutionContext::groupBufferToDeinterleavedResults().

                                                                                 {
   const size_t agg_col_count{agg_vals.size()};
   const auto row_size = query_mem_desc.getRowSize();
   CHECK_EQ(agg_col_count, query_mem_desc.getSlotCount());
   CHECK_GE(agg_col_count, targets.size());
   CHECK_EQ(is_columnar, query_mem_desc.didOutputColumnar());
   CHECK(query_mem_desc.hasKeylessHash());
   std::vector<int64_t> partial_agg_vals(agg_col_count, 0);
   bool discard_row = true;
   for (int8_t warp_idx = 0; warp_idx < warp_count; ++warp_idx) {
     bool discard_partial_result = true;
     for (size_t target_idx = 0, agg_col_idx = 0;
          target_idx < targets.size() && agg_col_idx < agg_col_count;
          ++target_idx, ++agg_col_idx) {
       const auto& agg_info = targets[target_idx];
       const bool float_argument_input = takes_float_argument(agg_info);
       const auto chosen_bytes = float_argument_input
                                     ? sizeof(float)
                                     : query_mem_desc.getPaddedSlotWidthBytes(agg_col_idx);
       auto partial_bin_val = get_component(
           row_ptr + query_mem_desc.getColOnlyOffInBytes(agg_col_idx), chosen_bytes);
       partial_agg_vals[agg_col_idx] = partial_bin_val;
       if (is_distinct_target(agg_info)) {
         CHECK_EQ(int8_t(1), warp_count);
         CHECK(agg_info.is_agg &&
               (agg_info.agg_kind == kCOUNT || agg_info.agg_kind == kCOUNT_IF ||
                agg_info.agg_kind == kAPPROX_COUNT_DISTINCT));
         partial_bin_val = count_distinct_set_size(
             partial_bin_val, query_mem_desc.getCountDistinctDescriptor(target_idx));
         if (replace_bitmap_ptr_with_bitmap_sz) {
           partial_agg_vals[agg_col_idx] = partial_bin_val;
         }
       }
       if (kAVG == agg_info.agg_kind) {
         CHECK(agg_info.is_agg && !agg_info.is_distinct);
         ++agg_col_idx;
         partial_bin_val = partial_agg_vals[agg_col_idx] =
             get_component(row_ptr + query_mem_desc.getColOnlyOffInBytes(agg_col_idx),
                           query_mem_desc.getPaddedSlotWidthBytes(agg_col_idx));
       }
       if (agg_col_idx == static_cast<size_t>(query_mem_desc.getTargetIdxForKey()) &&
           partial_bin_val != agg_init_vals[query_mem_desc.getTargetIdxForKey()]) {
         CHECK(agg_info.is_agg);
         discard_partial_result = false;
       }
     }
     row_ptr += row_size;
     if (discard_partial_result) {
       continue;
     }
     discard_row = false;
     for (size_t target_idx = 0, agg_col_idx = 0;
          target_idx < targets.size() && agg_col_idx < agg_col_count;
          ++target_idx, ++agg_col_idx) {
       auto partial_bin_val = partial_agg_vals[agg_col_idx];
       const auto& agg_info = targets[target_idx];
       const bool float_argument_input = takes_float_argument(agg_info);
       const auto chosen_bytes = float_argument_input
                                     ? sizeof(float)
                                     : query_mem_desc.getPaddedSlotWidthBytes(agg_col_idx);
       const auto& chosen_type = get_compact_type(agg_info);
       if (agg_info.is_agg && agg_info.agg_kind != kSAMPLE) {
         try {
           switch (agg_info.agg_kind) {
             case kCOUNT:
             case kCOUNT_IF:
             case kAPPROX_COUNT_DISTINCT:
               AGGREGATE_ONE_NULLABLE_COUNT(
                   reinterpret_cast<int8_t*>(&agg_vals[agg_col_idx]),
                   reinterpret_cast<int8_t*>(&partial_agg_vals[agg_col_idx]),
                   agg_init_vals[agg_col_idx],
                   chosen_bytes,
                   agg_info);
               break;
             case kAVG:
               // Ignore float argument compaction for count component for fear of its
               // overflow
               AGGREGATE_ONE_COUNT(
                   reinterpret_cast<int8_t*>(&agg_vals[agg_col_idx + 1]),
                   reinterpret_cast<int8_t*>(&partial_agg_vals[agg_col_idx + 1]),
                   query_mem_desc.getPaddedSlotWidthBytes(agg_col_idx));
             // fall thru
             case kSUM:
             case kSUM_IF:
               AGGREGATE_ONE_NULLABLE_VALUE(
                   sum,
                   reinterpret_cast<int8_t*>(&agg_vals[agg_col_idx]),
                   reinterpret_cast<int8_t*>(&partial_agg_vals[agg_col_idx]),
                   agg_init_vals[agg_col_idx],
                   chosen_bytes,
                   agg_info);
               break;
             case kMIN:
               if (static_cast<size_t>(chosen_bytes) <= sizeof(int16_t)) {
                 AGGREGATE_ONE_NULLABLE_VALUE_SMALL(
                     min,
                     reinterpret_cast<int8_t*>(&agg_vals[agg_col_idx]),
                     reinterpret_cast<int8_t*>(&partial_agg_vals[agg_col_idx]),
                     agg_init_vals[agg_col_idx],
                     chosen_bytes,
                     agg_info);
               } else {
                 AGGREGATE_ONE_NULLABLE_VALUE(
                     min,
                     reinterpret_cast<int8_t*>(&agg_vals[agg_col_idx]),
                     reinterpret_cast<int8_t*>(&partial_agg_vals[agg_col_idx]),
                     agg_init_vals[agg_col_idx],
                     chosen_bytes,
                     agg_info);
               }
               break;
             case kMAX:
               if (static_cast<size_t>(chosen_bytes) <= sizeof(int16_t)) {
                 AGGREGATE_ONE_NULLABLE_VALUE_SMALL(
                     max,
                     reinterpret_cast<int8_t*>(&agg_vals[agg_col_idx]),
                     reinterpret_cast<int8_t*>(&partial_agg_vals[agg_col_idx]),
                     agg_init_vals[agg_col_idx],
                     chosen_bytes,
                     agg_info);
               } else {
                 AGGREGATE_ONE_NULLABLE_VALUE(
                     max,
                     reinterpret_cast<int8_t*>(&agg_vals[agg_col_idx]),
                     reinterpret_cast<int8_t*>(&partial_agg_vals[agg_col_idx]),
                     agg_init_vals[agg_col_idx],
                     chosen_bytes,
                     agg_info);
               }
               break;
             default:
               CHECK(false);
               break;
           }
         } catch (std::runtime_error& e) {
           // TODO(miyu): handle the case where chosen_bytes < 8
           LOG(ERROR) << e.what();
         }
         if (chosen_type.is_integer() || chosen_type.is_decimal()) {
           switch (chosen_bytes) {
             case 8:
               break;
             case 4: {
               int32_t ret = *reinterpret_cast<const int32_t*>(&agg_vals[agg_col_idx]);
               if (!(shared::is_any<kCOUNT, kCOUNT_IF>(agg_info.agg_kind) &&
                     ret != agg_init_vals[agg_col_idx])) {
                 agg_vals[agg_col_idx] = static_cast<int64_t>(ret);
               }
               break;
             }
             default:
               CHECK(false);
           }
         }
         if (kAVG == agg_info.agg_kind) {
           ++agg_col_idx;
         }
       } else {
         if (agg_info.agg_kind == kSAMPLE) {
           CHECK(!agg_info.sql_type.is_varlen())
               << "Interleaved bins reduction not supported for variable length "
                  "arguments "
                  "to SAMPLE";
         }
         if (agg_vals[agg_col_idx]) {
           if (agg_info.agg_kind == kSAMPLE) {
             continue;
           }
           CHECK_EQ(agg_vals[agg_col_idx], partial_bin_val);
         } else {
           agg_vals[agg_col_idx] = partial_bin_val;
         }
       }
     }
   }
   return discard_row;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSetStorage::rewriteAggregateBufferOffsets ( const std::vector< std::string > & serialized_varlen_buffer ) const

Definition at line 542 of file ResultSetReduction.cpp.

References advance_slot(), advance_target_ptr_row_wise(), align_to_int64(), buff_, CHECK, CHECK_GT, CHECK_LT, QueryMemoryDescriptor::didOutputColumnar(), get_key_bytes_rowwise(), QueryMemoryDescriptor::getEntryCount(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), isEmptyEntry(), kSAMPLE, query_mem_desc_, row_ptr_rowwise(), and targets_.

                                                                 {
   if (serialized_varlen_buffer.empty()) {
     return;
   }
 
   CHECK(!query_mem_desc_.didOutputColumnar());
   auto entry_count = query_mem_desc_.getEntryCount();
   CHECK_GT(entry_count, size_t(0));
   CHECK(buff_);
 
   // Row-wise iteration, consider moving to separate function
   for (size_t i = 0; i < entry_count; ++i) {
     if (isEmptyEntry(i, buff_)) {
       continue;
     }
     const auto key_bytes = get_key_bytes_rowwise(query_mem_desc_);
     const auto key_bytes_with_padding = align_to_int64(key_bytes);
     auto rowwise_targets_ptr =
         row_ptr_rowwise(buff_, query_mem_desc_, i) + key_bytes_with_padding;
     size_t target_slot_idx = 0;
     for (size_t target_logical_idx = 0; target_logical_idx < targets_.size();
          ++target_logical_idx) {
       const auto& target_info = targets_[target_logical_idx];
       if (target_info.sql_type.is_varlen() && target_info.is_agg) {
         CHECK(target_info.agg_kind == kSAMPLE);
         auto ptr1 = rowwise_targets_ptr;
         auto slot_idx = target_slot_idx;
         auto ptr2 = ptr1 + query_mem_desc_.getPaddedSlotWidthBytes(slot_idx);
         auto offset = *reinterpret_cast<const int64_t*>(ptr1);
 
         const auto& elem_ti = target_info.sql_type.get_elem_type();
         size_t length_to_elems =
             target_info.sql_type.is_string() || target_info.sql_type.is_geometry()
                 ? 1
                 : elem_ti.get_size();
         if (target_info.sql_type.is_geometry()) {
           for (int j = 0; j < target_info.sql_type.get_physical_coord_cols(); j++) {
             if (j > 0) {
               ptr1 = ptr2 + query_mem_desc_.getPaddedSlotWidthBytes(slot_idx + 1);
               ptr2 = ptr1 + query_mem_desc_.getPaddedSlotWidthBytes(slot_idx + 2);
               slot_idx += 2;
               length_to_elems = 4;
             }
             CHECK_LT(static_cast<size_t>(offset), serialized_varlen_buffer.size());
             const auto& varlen_bytes_str = serialized_varlen_buffer[offset++];
             const auto str_ptr =
                 reinterpret_cast<const int8_t*>(varlen_bytes_str.c_str());
             CHECK(ptr1);
             *reinterpret_cast<int64_t*>(ptr1) = reinterpret_cast<const int64_t>(str_ptr);
             CHECK(ptr2);
             *reinterpret_cast<int64_t*>(ptr2) =
                 static_cast<int64_t>(varlen_bytes_str.size() / length_to_elems);
           }
         } else {
           CHECK_LT(static_cast<size_t>(offset), serialized_varlen_buffer.size());
           const auto& varlen_bytes_str = serialized_varlen_buffer[offset];
           const auto str_ptr = reinterpret_cast<const int8_t*>(varlen_bytes_str.c_str());
           CHECK(ptr1);
           *reinterpret_cast<int64_t*>(ptr1) = reinterpret_cast<const int64_t>(str_ptr);
           CHECK(ptr2);
           *reinterpret_cast<int64_t*>(ptr2) =
               static_cast<int64_t>(varlen_bytes_str.size() / length_to_elems);
         }
       }
 
       rowwise_targets_ptr = advance_target_ptr_row_wise(
           rowwise_targets_ptr, target_info, target_slot_idx, query_mem_desc_, false);
       target_slot_idx = advance_slot(target_slot_idx, target_info, false);
     }
   }
 
   return;
 }

Here is the call graph for this function:

void ResultSetStorage::updateEntryCount ( const size_t new_entry_count )

inline

Definition at line 128 of file ResultSetStorage.h.

References query_mem_desc_, and QueryMemoryDescriptor::setEntryCount().

                                                       {
     query_mem_desc_.setEntryCount(new_entry_count);
   }

Here is the call graph for this function:

Friends And Related Function Documentation

friend class ResultSet

friend

Definition at line 250 of file ResultSetStorage.h.

friend class ResultSetManager

friend

Definition at line 251 of file ResultSetStorage.h.

Member Data Documentation

int8_t* ResultSetStorage::buff_

private

Definition at line 237 of file ResultSetStorage.h.

Referenced by fillOneEntryColWise(), fillOneEntryRowWise(), getUnderlyingBuffer(), initializeColWise(), initializeRowWise(), moveEntriesToBuffer(), reduce(), and rewriteAggregateBufferOffsets().

const bool ResultSetStorage::buff_is_provided_

private

Definition at line 238 of file ResultSetStorage.h.

std::unordered_map<int64_t, int64_t> ResultSetStorage::count_distinct_sets_mapping_

private

Definition at line 245 of file ResultSetStorage.h.

Referenced by addCountDistinctSetPointerMapping(), and mappedPtr().

QueryMemoryDescriptor ResultSetStorage::query_mem_desc_

private

std::vector<int64_t> ResultSetStorage::target_init_vals_

private

Definition at line 239 of file ResultSetStorage.h.

Referenced by fillOneEntryColWise(), fillOneEntryRowWise(), initializeBaselineValueSlots(), initializeColWise(), initializeRowWise(), reduceOneSlot(), and reduceOneSlotSingleValue().

const std::vector<TargetInfo> ResultSetStorage::targets_

private

Definition at line 235 of file ResultSetStorage.h.

Referenced by reduceEntriesNoCollisionsColWise(), reduceOneEntrySlotsBaseline(), and rewriteAggregateBufferOffsets().

std::shared_ptr<VarlenOutputInfo> ResultSetStorage::varlen_output_info_

private

Definition at line 248 of file ResultSetStorage.h.

Referenced by getVarlenOutputInfo().

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

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ResultSetStorage.h
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ResultSetIteration.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ResultSetReduction.cpp
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ResultSetStorage.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation