Collaboration diagram for ResultSet::RowWiseTargetAccessor:

Public Member Functions
	RowWiseTargetAccessor (const ResultSet *result_set)

InternalTargetValue	getColumnInternal (const int8_t *buff, const size_t entry_idx, const size_t target_logical_idx, const StorageLookupResult &storage_lookup_result) const

void	initializeOffsetsForStorage ()

const int8_t *	get_rowwise_ptr (const int8_t *buff, const size_t entry_idx) const

Public Attributes
std::vector< std::vector < TargetOffsets > >	offsets_for_storage_

const ResultSet *	result_set_

const size_t	row_bytes_

const size_t	key_width_

const size_t	key_bytes_with_padding_

Detailed Description

Definition at line 778 of file ResultSet.h.

Constructor & Destructor Documentation

ResultSet::RowWiseTargetAccessor::RowWiseTargetAccessor ( const ResultSet * result_set )

inline

Definition at line 779 of file ResultSet.h.

References initializeOffsetsForStorage().

         : result_set_(result_set)
         , row_bytes_(get_row_bytes(result_set->query_mem_desc_))
         , key_width_(result_set_->query_mem_desc_.getEffectiveKeyWidth())
         , key_bytes_with_padding_(
               align_to_int64(get_key_bytes_rowwise(result_set->query_mem_desc_))) {
       initializeOffsetsForStorage();
     }

Here is the call graph for this function:

Member Function Documentation

const int8_t* ResultSet::RowWiseTargetAccessor::get_rowwise_ptr	(	const int8_t *	buff,
		const size_t	entry_idx
	)		const

inline

Definition at line 796 of file ResultSet.h.

References row_bytes_.

                                                                        {
       return buff + entry_idx * row_bytes_;
     }

InternalTargetValue ResultSet::RowWiseTargetAccessor::getColumnInternal	(	const int8_t *	buff,
		const size_t	entry_idx,
		const size_t	target_logical_idx,
		const StorageLookupResult &	storage_lookup_result
	)		const

Definition at line 424 of file ResultSetIteration.cpp.

References CHECK, CHECK_EQ, CHECK_GE, CHECK_LT, anonymous_namespace{ResultSetIteration.cpp}::int_resize_cast(), kAVG, kENCODING_NONE, kMODE, read_int_from_buff(), and ResultSet::StorageLookupResult::storage_idx.

                                                             {
   CHECK(buff);
   const int8_t* rowwise_target_ptr{nullptr};
   const int8_t* keys_ptr{nullptr};
 
   const size_t storage_idx = storage_lookup_result.storage_idx;
 
   CHECK_LT(storage_idx, offsets_for_storage_.size());
   CHECK_LT(target_logical_idx, offsets_for_storage_[storage_idx].size());
 
   const auto& offsets_for_target = offsets_for_storage_[storage_idx][target_logical_idx];
   const auto& agg_info = result_set_->storage_->targets_[target_logical_idx];
   const auto& type_info = agg_info.sql_type;
 
   keys_ptr = get_rowwise_ptr(buff, entry_idx);
   rowwise_target_ptr = keys_ptr + key_bytes_with_padding_;
   auto ptr1 = rowwise_target_ptr + reinterpret_cast<size_t>(offsets_for_target.ptr1);
   if (result_set_->query_mem_desc_.targetGroupbyIndicesSize() > 0) {
     if (result_set_->query_mem_desc_.getTargetGroupbyIndex(target_logical_idx) >= 0) {
       ptr1 = keys_ptr +
              result_set_->query_mem_desc_.getTargetGroupbyIndex(target_logical_idx) *
                  key_width_;
     }
   }
   const auto i1 =
       result_set_->lazyReadInt(read_int_from_buff(ptr1, offsets_for_target.compact_sz1),
                                target_logical_idx,
                                storage_lookup_result);
   if (agg_info.is_agg && agg_info.agg_kind == kAVG) {
     CHECK(offsets_for_target.ptr2);
     const auto ptr2 =
         rowwise_target_ptr + reinterpret_cast<size_t>(offsets_for_target.ptr2);
     const auto i2 = read_int_from_buff(ptr2, offsets_for_target.compact_sz2);
     return InternalTargetValue(i1, i2);
   } else {
     if (type_info.is_string() && type_info.get_compression() == kENCODING_NONE) {
       CHECK(!agg_info.is_agg);
       if (!result_set_->lazy_fetch_info_.empty()) {
         CHECK_LT(target_logical_idx, result_set_->lazy_fetch_info_.size());
         const auto& col_lazy_fetch = result_set_->lazy_fetch_info_[target_logical_idx];
         if (col_lazy_fetch.is_lazily_fetched) {
           return InternalTargetValue(reinterpret_cast<const std::string*>(i1));
         }
       }
       if (result_set_->separate_varlen_storage_valid_) {
         if (i1 < 0) {
           CHECK_EQ(-1, i1);
           return InternalTargetValue(static_cast<const std::string*>(nullptr));
         }
         CHECK_LT(storage_lookup_result.storage_idx,
                  result_set_->serialized_varlen_buffer_.size());
         const auto& varlen_buffer_for_fragment =
             result_set_->serialized_varlen_buffer_[storage_lookup_result.storage_idx];
         CHECK_LT(static_cast<size_t>(i1), varlen_buffer_for_fragment.size());
         return InternalTargetValue(&varlen_buffer_for_fragment[i1]);
       }
       CHECK(offsets_for_target.ptr2);
       const auto ptr2 =
           rowwise_target_ptr + reinterpret_cast<size_t>(offsets_for_target.ptr2);
       const auto str_len = read_int_from_buff(ptr2, offsets_for_target.compact_sz2);
       CHECK_GE(str_len, 0);
       return result_set_->getVarlenOrderEntry(i1, str_len);
     } else if (agg_info.is_agg && agg_info.agg_kind == kMODE) {
       return InternalTargetValue(i1);  // AggMode*
     }
     return InternalTargetValue(
         type_info.is_fp() ? i1 : int_resize_cast(i1, type_info.get_logical_size()));
   }
 }

Here is the call graph for this function:

void ResultSet::RowWiseTargetAccessor::initializeOffsetsForStorage ( )

Definition at line 370 of file ResultSetIteration.cpp.

References advance_slot(), advance_target_ptr_row_wise(), CHECK_EQ, is_real_str_or_array(), kAVG, key_width_, offsets_for_storage_, and result_set_.

Referenced by RowWiseTargetAccessor().

                                                                  {
   // Compute offsets for base storage and all appended storage
   for (size_t storage_idx = 0; storage_idx < result_set_->appended_storage_.size() + 1;
        ++storage_idx) {
     offsets_for_storage_.emplace_back();
 
     const int8_t* rowwise_target_ptr{0};
 
     size_t agg_col_idx = 0;
     for (size_t target_idx = 0; target_idx < result_set_->storage_->targets_.size();
          ++target_idx) {
       const auto& agg_info = result_set_->storage_->targets_[target_idx];
 
       auto ptr1 = rowwise_target_ptr;
       const auto compact_sz1 =
           result_set_->query_mem_desc_.getPaddedSlotWidthBytes(agg_col_idx)
               ? result_set_->query_mem_desc_.getPaddedSlotWidthBytes(agg_col_idx)
               : key_width_;
 
       const int8_t* ptr2{nullptr};
       int8_t compact_sz2{0};
       if ((agg_info.is_agg && agg_info.agg_kind == kAVG)) {
         ptr2 = ptr1 + compact_sz1;
         compact_sz2 =
             result_set_->query_mem_desc_.getPaddedSlotWidthBytes(agg_col_idx + 1);
       } else if (is_real_str_or_array(agg_info)) {
         ptr2 = ptr1 + compact_sz1;
         if (!result_set_->separate_varlen_storage_valid_) {
           // None encoded strings explicitly attached to ResultSetStorage do not have a
           // second slot in the QueryMemoryDescriptor col width vector
           compact_sz2 =
               result_set_->query_mem_desc_.getPaddedSlotWidthBytes(agg_col_idx + 1);
         }
       }
       offsets_for_storage_[storage_idx].push_back(
           TargetOffsets{ptr1,
                         static_cast<size_t>(compact_sz1),
                         ptr2,
                         static_cast<size_t>(compact_sz2)});
       rowwise_target_ptr =
           advance_target_ptr_row_wise(rowwise_target_ptr,
                                       agg_info,
                                       agg_col_idx,
                                       result_set_->query_mem_desc_,
                                       result_set_->separate_varlen_storage_valid_);
 
       agg_col_idx = advance_slot(
           agg_col_idx, agg_info, result_set_->separate_varlen_storage_valid_);
     }
     CHECK_EQ(offsets_for_storage_[storage_idx].size(),
              result_set_->storage_->targets_.size());
   }
 }