#include <ResultSet.h>

Collaboration diagram for ResultSet:

Classes
struct	ColumnWiseTargetAccessor

struct	QueryExecutionTimings

struct	ResultSetComparator

struct	RowWiseTargetAccessor

struct	StorageLookupResult

struct	TargetOffsets

struct	VarlenTargetPtrPair

Public Types
enum	GeoReturnType { GeoReturnType::GeoTargetValue, GeoReturnType::WktString, GeoReturnType::GeoTargetValuePtr, GeoReturnType::GeoTargetValueGpuPtr }

Public Member Functions
	ResultSet (const std::vector< TargetInfo > &targets, const ExecutorDeviceType device_type, const QueryMemoryDescriptor &query_mem_desc, const std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner, const Catalog_Namespace::Catalog *catalog, const unsigned block_size, const unsigned grid_size)

	ResultSet (const std::vector< TargetInfo > &targets, const std::vector< ColumnLazyFetchInfo > &lazy_fetch_info, const std::vector< std::vector< const int8_t * >> &col_buffers, const std::vector< std::vector< int64_t >> &frag_offsets, const std::vector< int64_t > &consistent_frag_sizes, const ExecutorDeviceType device_type, const int device_id, const QueryMemoryDescriptor &query_mem_desc, const std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner, const Catalog_Namespace::Catalog *catalog, const unsigned block_size, const unsigned grid_size)

	ResultSet (const std::shared_ptr< const Analyzer::Estimator >, const ExecutorDeviceType device_type, const int device_id, Data_Namespace::DataMgr *data_mgr)

	ResultSet (const std::string &explanation)

	ResultSet (int64_t queue_time_ms, int64_t render_time_ms, const std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner)

	~ResultSet ()

std::string	toString () const

ResultSetRowIterator	rowIterator (size_t from_logical_index, bool translate_strings, bool decimal_to_double) const

ResultSetRowIterator	rowIterator (bool translate_strings, bool decimal_to_double) const

ExecutorDeviceType	getDeviceType () const

const ResultSetStorage *	allocateStorage () const

const ResultSetStorage *	allocateStorage (int8_t *, const std::vector< int64_t > &, std::shared_ptr< VarlenOutputInfo >=nullptr) const

const ResultSetStorage *	allocateStorage (const std::vector< int64_t > &) const

void	updateStorageEntryCount (const size_t new_entry_count)

std::vector< TargetValue >	getNextRow (const bool translate_strings, const bool decimal_to_double) const

size_t	getCurrentRowBufferIndex () const

std::vector< TargetValue >	getRowAt (const size_t index) const

TargetValue	getRowAt (const size_t row_idx, const size_t col_idx, const bool translate_strings, const bool decimal_to_double=true) const

OneIntegerColumnRow	getOneColRow (const size_t index) const

std::vector< TargetValue >	getRowAtNoTranslations (const size_t index, const std::vector< bool > &targets_to_skip={}) const

bool	isRowAtEmpty (const size_t index) const

void	sort (const std::list< Analyzer::OrderEntry > &order_entries, size_t top_n, const Executor *executor)

void	keepFirstN (const size_t n)

void	dropFirstN (const size_t n)

void	append (ResultSet &that)

const ResultSetStorage *	getStorage () const

size_t	colCount () const

SQLTypeInfo	getColType (const size_t col_idx) const

size_t	rowCount (const bool force_parallel=false) const

void	setCachedRowCount (const size_t row_count) const

bool	isEmpty () const

size_t	entryCount () const

size_t	getBufferSizeBytes (const ExecutorDeviceType device_type) const

bool	definitelyHasNoRows () const

const QueryMemoryDescriptor &	getQueryMemDesc () const

const std::vector< TargetInfo > &	getTargetInfos () const

const std::vector< int64_t > &	getTargetInitVals () const

int8_t *	getDeviceEstimatorBuffer () const

int8_t *	getHostEstimatorBuffer () const

void	syncEstimatorBuffer () const

size_t	getNDVEstimator () const

void	setQueueTime (const int64_t queue_time)

void	setKernelQueueTime (const int64_t kernel_queue_time)

void	addCompilationQueueTime (const int64_t compilation_queue_time)

int64_t	getQueueTime () const

int64_t	getRenderTime () const

void	moveToBegin () const

bool	isTruncated () const

bool	isExplain () const

void	setValidationOnlyRes ()

bool	isValidationOnlyRes () const

std::string	getExplanation () const

bool	isGeoColOnGpu (const size_t col_idx) const

int	getDeviceId () const

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

void	initializeStorage () const

void	holdChunks (const std::list< std::shared_ptr< Chunk_NS::Chunk >> &chunks)

void	holdChunkIterators (const std::shared_ptr< std::list< ChunkIter >> chunk_iters)

void	holdLiterals (std::vector< int8_t > &literal_buff)

std::shared_ptr < RowSetMemoryOwner >	getRowSetMemOwner () const

const Permutation &	getPermutationBuffer () const

const bool	isPermutationBufferEmpty () const

void	serialize (TSerializedRows &serialized_rows) const

size_t	getLimit () const

GeoReturnType	getGeoReturnType () const

void	setGeoReturnType (const GeoReturnType val)

void	copyColumnIntoBuffer (const size_t column_idx, int8_t *output_buffer, const size_t output_buffer_size) const

bool	isDirectColumnarConversionPossible () const

bool	didOutputColumnar () const

bool	isZeroCopyColumnarConversionPossible (size_t column_idx) const

const int8_t *	getColumnarBuffer (size_t column_idx) const

QueryDescriptionType	getQueryDescriptionType () const

const int8_t	getPaddedSlotWidthBytes (const size_t slot_idx) const

std::tuple< std::vector< bool > , size_t >	getSingleSlotTargetBitmap () const

std::tuple< std::vector< bool > , size_t >	getSupportedSingleSlotTargetBitmap () const

std::vector< size_t >	getSlotIndicesForTargetIndices () const

const std::vector < ColumnLazyFetchInfo > &	getLazyFetchInfo () const

void	setSeparateVarlenStorageValid (const bool val)

std::shared_ptr< const std::vector< std::string > >	getStringDictionaryPayloadCopy (const int dict_id) const

template<typename ENTRY_TYPE , QueryDescriptionType QUERY_TYPE, bool COLUMNAR_FORMAT>
ENTRY_TYPE	getEntryAt (const size_t row_idx, const size_t target_idx, const size_t slot_idx) const

template<typename ENTRY_TYPE , QueryDescriptionType QUERY_TYPE, bool COLUMNAR_FORMAT>
ENTRY_TYPE	getEntryAt (const size_t row_idx, const size_t target_idx, const size_t slot_idx) const

template<typename ENTRY_TYPE >
ENTRY_TYPE	getColumnarPerfectHashEntryAt (const size_t row_idx, const size_t target_idx, const size_t slot_idx) const

template<typename ENTRY_TYPE >
ENTRY_TYPE	getRowWisePerfectHashEntryAt (const size_t row_idx, const size_t target_idx, const size_t slot_idx) const

template<typename ENTRY_TYPE >
ENTRY_TYPE	getRowWiseBaselineEntryAt (const size_t row_idx, const size_t target_idx, const size_t slot_idx) const

template<typename ENTRY_TYPE >
ENTRY_TYPE	getColumnarBaselineEntryAt (const size_t row_idx, const size_t target_idx, const size_t slot_idx) const

Static Public Member Functions
static QueryMemoryDescriptor	fixupQueryMemoryDescriptor (const QueryMemoryDescriptor &)

static std::unique_ptr< ResultSet >	unserialize (const TSerializedRows &serialized_rows, const Executor *)

static double	calculateQuantile (quantile::TDigest *const t_digest)

Public Attributes
friend	ResultSetBuilder

Private Types
using	ApproxQuantileBuffers = std::vector< std::vector< double >>

using	BufferSet = std::set< int64_t >

using	SerializedVarlenBufferStorage = std::vector< std::string >

Private Member Functions
void	advanceCursorToNextEntry (ResultSetRowIterator &iter) const

std::vector< TargetValue >	getNextRowImpl (const bool translate_strings, const bool decimal_to_double) const

std::vector< TargetValue >	getNextRowUnlocked (const bool translate_strings, const bool decimal_to_double) const

std::vector< TargetValue >	getRowAt (const size_t index, const bool translate_strings, const bool decimal_to_double, const bool fixup_count_distinct_pointers, const std::vector< bool > &targets_to_skip={}) const

template<typename ENTRY_TYPE >
ENTRY_TYPE	getColumnarPerfectHashEntryAt (const size_t row_idx, const size_t target_idx, const size_t slot_idx) const

template<typename ENTRY_TYPE >
ENTRY_TYPE	getRowWisePerfectHashEntryAt (const size_t row_idx, const size_t target_idx, const size_t slot_idx) const

template<typename ENTRY_TYPE >
ENTRY_TYPE	getRowWiseBaselineEntryAt (const size_t row_idx, const size_t target_idx, const size_t slot_idx) const

template<typename ENTRY_TYPE >
ENTRY_TYPE	getColumnarBaselineEntryAt (const size_t row_idx, const size_t target_idx, const size_t slot_idx) const

size_t	binSearchRowCount () const

size_t	parallelRowCount () const

size_t	advanceCursorToNextEntry () const

void	radixSortOnGpu (const std::list< Analyzer::OrderEntry > &order_entries) const

void	radixSortOnCpu (const std::list< Analyzer::OrderEntry > &order_entries) const

TargetValue	getTargetValueFromBufferRowwise (int8_t rowwise_target_ptr, int8_t keys_ptr, const size_t entry_buff_idx, const TargetInfo &target_info, const size_t target_logical_idx, const size_t slot_idx, const bool translate_strings, const bool decimal_to_double, const bool fixup_count_distinct_pointers) const

TargetValue	getTargetValueFromBufferColwise (const int8_t col_ptr, const int8_t keys_ptr, const QueryMemoryDescriptor &query_mem_desc, const size_t local_entry_idx, const size_t global_entry_idx, const TargetInfo &target_info, const size_t target_logical_idx, const size_t slot_idx, const bool translate_strings, const bool decimal_to_double) const

TargetValue	makeTargetValue (const int8_t *ptr, const int8_t compact_sz, const TargetInfo &target_info, const size_t target_logical_idx, const bool translate_strings, const bool decimal_to_double, const size_t entry_buff_idx) const

TargetValue	makeVarlenTargetValue (const int8_t ptr1, const int8_t compact_sz1, const int8_t ptr2, const int8_t compact_sz2, const TargetInfo &target_info, const size_t target_logical_idx, const bool translate_strings, const size_t entry_buff_idx) const

TargetValue	makeGeoTargetValue (const int8_t *geo_target_ptr, const size_t slot_idx, const TargetInfo &target_info, const size_t target_logical_idx, const size_t entry_buff_idx) const

InternalTargetValue	getVarlenOrderEntry (const int64_t str_ptr, const size_t str_len) const

int64_t	lazyReadInt (const int64_t ival, const size_t target_logical_idx, const StorageLookupResult &storage_lookup_result) const

std::pair< size_t, size_t >	getStorageIndex (const size_t entry_idx) const

const std::vector< const int8_t * > &	getColumnFrag (const size_t storge_idx, const size_t col_logical_idx, int64_t &global_idx) const

const VarlenOutputInfo *	getVarlenOutputInfo (const size_t entry_idx) const

StorageLookupResult	findStorage (const size_t entry_idx) const

Comparator	createComparator (const std::list< Analyzer::OrderEntry > &order_entries, const PermutationView permutation, const Executor *executor, const bool single_threaded)

PermutationView	initPermutationBuffer (PermutationView permutation, PermutationIdx const begin, PermutationIdx const end) const

void	parallelTop (const std::list< Analyzer::OrderEntry > &order_entries, const size_t top_n, const Executor *executor)

void	baselineSort (const std::list< Analyzer::OrderEntry > &order_entries, const size_t top_n, const Executor *executor)

void	doBaselineSort (const ExecutorDeviceType device_type, const std::list< Analyzer::OrderEntry > &order_entries, const size_t top_n, const Executor *executor)

bool	canUseFastBaselineSort (const std::list< Analyzer::OrderEntry > &order_entries, const size_t top_n)

Data_Namespace::DataMgr *	getDataManager () const

int	getGpuCount () const

void	serializeProjection (TSerializedRows &serialized_rows) const

void	serializeVarlenAggColumn (int8_t *buf, std::vector< std::string > &varlen_bufer) const

void	serializeCountDistinctColumns (TSerializedRows &) const

void	unserializeCountDistinctColumns (const TSerializedRows &)

void	fixupCountDistinctPointers ()

void	create_active_buffer_set (BufferSet &count_distinct_active_buffer_set) const

int64_t	getDistinctBufferRefFromBufferRowwise (int8_t *rowwise_target_ptr, const TargetInfo &target_info) const

Static Private Member Functions
static bool	isNull (const SQLTypeInfo &ti, const InternalTargetValue &val, const bool float_argument_input)

static PermutationView	topPermutation (PermutationView, const size_t n, const Comparator &)

Private Attributes
const std::vector< TargetInfo >	targets_

const ExecutorDeviceType	device_type_

const int	device_id_

QueryMemoryDescriptor	query_mem_desc_

std::unique_ptr< ResultSetStorage >	storage_

AppendedStorage	appended_storage_

size_t	crt_row_buff_idx_

size_t	fetched_so_far_

size_t	drop_first_

size_t	keep_first_

std::shared_ptr < RowSetMemoryOwner >	row_set_mem_owner_

Permutation	permutation_

const Catalog_Namespace::Catalog *	catalog_

unsigned	block_size_ {0}

unsigned	grid_size_ {0}

QueryExecutionTimings	timings_

std::list< std::shared_ptr < Chunk_NS::Chunk > >	chunks_

std::vector< std::shared_ptr < std::list< ChunkIter > > >	chunk_iters_

std::vector< std::vector < int8_t > >	literal_buffers_

const std::vector < ColumnLazyFetchInfo >	lazy_fetch_info_

std::vector< std::vector < std::vector< const int8_t * > > >	col_buffers_

std::vector< std::vector < std::vector< int64_t > > >	frag_offsets_

std::vector< std::vector < int64_t > >	consistent_frag_sizes_

const std::shared_ptr< const Analyzer::Estimator >	estimator_

Data_Namespace::AbstractBuffer *	device_estimator_buffer_ {nullptr}

int8_t *	host_estimator_buffer_ {nullptr}

Data_Namespace::DataMgr *	data_mgr_

std::vector < SerializedVarlenBufferStorage >	serialized_varlen_buffer_

bool	separate_varlen_storage_valid_

std::string	explanation_

const bool	just_explain_

bool	for_validation_only_

std::atomic< int64_t >	cached_row_count_

std::mutex	row_iteration_mutex_

GeoReturnType	geo_return_type_

Friends
class	ResultSetManager

class	ResultSetRowIterator

class	ColumnarResults

Detailed Description

Definition at line 157 of file ResultSet.h.

Member Typedef Documentation

using ResultSet::ApproxQuantileBuffers = std::vector<std::vector<double>>

private

Definition at line 633 of file ResultSet.h.

using ResultSet::BufferSet = std::set<int64_t>

private

Definition at line 732 of file ResultSet.h.

using ResultSet::SerializedVarlenBufferStorage = std::vector<std::string>

private

Definition at line 772 of file ResultSet.h.

Member Enumeration Documentation

enum ResultSet::GeoReturnType

strong

Geo return type options when accessing geo columns from a result set.

Enumerator
GeoTargetValue	Copies the geo data into a struct of vectors - coords are uncompressed
WktString	Returns the geo data as a WKT string
GeoTargetValuePtr	Returns only the pointers of the underlying buffers for the geo data.
GeoTargetValueGpuPtr	If geo data is currently on a device, keep the data on the device and return the device ptrs

Definition at line 389 of file ResultSet.h.

                            {
     GeoTargetValue,      
     WktString,           
     GeoTargetValuePtr,   
     GeoTargetValueGpuPtr 
   };

Constructor & Destructor Documentation

ResultSet::ResultSet	(	const std::vector< TargetInfo > &	targets,
		const ExecutorDeviceType	device_type,
		const QueryMemoryDescriptor &	query_mem_desc,
		const std::shared_ptr< RowSetMemoryOwner >	row_set_mem_owner,
		const Catalog_Namespace::Catalog *	catalog,
		const unsigned	block_size,
		const unsigned	grid_size
	)

Definition at line 57 of file ResultSet.cpp.

     : targets_(targets)
     , device_type_(device_type)
     , device_id_(-1)
     , query_mem_desc_(query_mem_desc)
     , crt_row_buff_idx_(0)
     , fetched_so_far_(0)
     , drop_first_(0)
     , keep_first_(0)
     , row_set_mem_owner_(row_set_mem_owner)
     , catalog_(catalog)
     , block_size_(block_size)
     , grid_size_(grid_size)
     , data_mgr_(nullptr)
     , separate_varlen_storage_valid_(false)
     , just_explain_(false)
     , for_validation_only_(false)
     , cached_row_count_(-1)
     , geo_return_type_(GeoReturnType::WktString) {}

ResultSet::ResultSet	(	const std::vector< TargetInfo > &	targets,
		const std::vector< ColumnLazyFetchInfo > &	lazy_fetch_info,
		const std::vector< std::vector< const int8_t * >> &	col_buffers,
		const std::vector< std::vector< int64_t >> &	frag_offsets,
		const std::vector< int64_t > &	consistent_frag_sizes,
		const ExecutorDeviceType	device_type,
		const int	device_id,
		const QueryMemoryDescriptor &	query_mem_desc,
		const std::shared_ptr< RowSetMemoryOwner >	row_set_mem_owner,
		const Catalog_Namespace::Catalog *	catalog,
		const unsigned	block_size,
		const unsigned	grid_size
	)

Definition at line 83 of file ResultSet.cpp.

     : targets_(targets)
     , device_type_(device_type)
     , device_id_(device_id)
     , query_mem_desc_(query_mem_desc)
     , crt_row_buff_idx_(0)
     , fetched_so_far_(0)
     , drop_first_(0)
     , keep_first_(0)
     , row_set_mem_owner_(row_set_mem_owner)
     , catalog_(catalog)
     , block_size_(block_size)
     , grid_size_(grid_size)
     , lazy_fetch_info_(lazy_fetch_info)
     , col_buffers_{col_buffers}
     , frag_offsets_{frag_offsets}
     , consistent_frag_sizes_{consistent_frag_sizes}
     , data_mgr_(nullptr)
     , separate_varlen_storage_valid_(false)
     , just_explain_(false)
     , for_validation_only_(false)
     , cached_row_count_(-1)
     , geo_return_type_(GeoReturnType::WktString) {}

ResultSet::ResultSet	(	const std::shared_ptr< const Analyzer::Estimator >	,
		const ExecutorDeviceType	device_type,
		const int	device_id,
		Data_Namespace::DataMgr *	data_mgr
	)

ResultSet::ResultSet ( const std::string & explanation )

Definition at line 145 of file ResultSet.cpp.

References CPU.

     : device_type_(ExecutorDeviceType::CPU)
     , device_id_(-1)
     , fetched_so_far_(0)
     , separate_varlen_storage_valid_(false)
     , explanation_(explanation)
     , just_explain_(true)
     , for_validation_only_(false)
     , cached_row_count_(-1)
     , geo_return_type_(GeoReturnType::WktString) {}

ResultSet::ResultSet	(	int64_t	queue_time_ms,
		int64_t	render_time_ms,
		const std::shared_ptr< RowSetMemoryOwner >	row_set_mem_owner
	)

Definition at line 156 of file ResultSet.cpp.

References CPU.

     : device_type_(ExecutorDeviceType::CPU)
     , device_id_(-1)
     , fetched_so_far_(0)
     , row_set_mem_owner_(row_set_mem_owner)
     , timings_(QueryExecutionTimings{queue_time_ms, render_time_ms, 0, 0})
     , separate_varlen_storage_valid_(false)
     , just_explain_(true)
     , for_validation_only_(false)
     , cached_row_count_(-1)
     , geo_return_type_(GeoReturnType::WktString){};

ResultSet::~ResultSet ( )

Definition at line 170 of file ResultSet.cpp.

References CHECK, CPU, and data_mgr_().

                       {
   if (storage_) {
     if (!storage_->buff_is_provided_) {
       CHECK(storage_->getUnderlyingBuffer());
       free(storage_->getUnderlyingBuffer());
     }
   }
   for (auto& storage : appended_storage_) {
     if (storage && !storage->buff_is_provided_) {
       free(storage->getUnderlyingBuffer());
     }
   }
   if (host_estimator_buffer_) {
     CHECK(device_type_ == ExecutorDeviceType::CPU || device_estimator_buffer_);
     free(host_estimator_buffer_);
   }
   if (device_estimator_buffer_) {
     CHECK(data_mgr_);
     data_mgr_->free(device_estimator_buffer_);
   }
 }

Here is the call graph for this function:

Member Function Documentation

void ResultSet::addCompilationQueueTime ( const int64_t compilation_queue_time )

Definition at line 453 of file ResultSet.cpp.

                                                                             {
   timings_.compilation_queue_time += compilation_queue_time;
 }

void ResultSet::advanceCursorToNextEntry ( ResultSetRowIterator & iter ) const

private

size_t ResultSet::advanceCursorToNextEntry ( ) const

private

const ResultSetStorage* ResultSet::allocateStorage ( ) const

const ResultSetStorage* ResultSet::allocateStorage	(	int8_t *	,
		const std::vector< int64_t > &	,
		std::shared_ptr< VarlenOutputInfo >	= `nullptr`
	)		const

const ResultSetStorage* ResultSet::allocateStorage ( const std::vector< int64_t > & ) const

void ResultSet::append ( ResultSet & that )

Definition at line 241 of file ResultSet.cpp.

References CHECK, and CHECK_EQ.

                                       {
   CHECK_EQ(-1, cached_row_count_);
   if (!that.storage_) {
     return;
   }
   appended_storage_.push_back(std::move(that.storage_));
   query_mem_desc_.setEntryCount(
       query_mem_desc_.getEntryCount() +
       appended_storage_.back()->query_mem_desc_.getEntryCount());
   chunks_.insert(chunks_.end(), that.chunks_.begin(), that.chunks_.end());
   col_buffers_.insert(
       col_buffers_.end(), that.col_buffers_.begin(), that.col_buffers_.end());
   frag_offsets_.insert(
       frag_offsets_.end(), that.frag_offsets_.begin(), that.frag_offsets_.end());
   consistent_frag_sizes_.insert(consistent_frag_sizes_.end(),
                                 that.consistent_frag_sizes_.begin(),
                                 that.consistent_frag_sizes_.end());
   chunk_iters_.insert(
       chunk_iters_.end(), that.chunk_iters_.begin(), that.chunk_iters_.end());
   if (separate_varlen_storage_valid_) {
     CHECK(that.separate_varlen_storage_valid_);
     serialized_varlen_buffer_.insert(serialized_varlen_buffer_.end(),
                                      that.serialized_varlen_buffer_.begin(),
                                      that.serialized_varlen_buffer_.end());
   }
   for (auto& buff : that.literal_buffers_) {
     literal_buffers_.push_back(std::move(buff));
   }
 }

void ResultSet::baselineSort	(	const std::list< Analyzer::OrderEntry > &	order_entries,
		const size_t	top_n,
		const Executor *	executor
	)

private

size_t ResultSet::binSearchRowCount ( ) const

private

Definition at line 351 of file ResultSet.cpp.

References anonymous_namespace{ResultSet.cpp}::get_truncated_row_count().

                                           {
   if (!storage_) {
     return 0;
   }
 
   size_t row_count = storage_->binSearchRowCount();
   for (auto& s : appended_storage_) {
     row_count += s->binSearchRowCount();
   }
 
   return get_truncated_row_count(row_count, getLimit(), drop_first_);
 }

Here is the call graph for this function:

double ResultSet::calculateQuantile ( quantile::TDigest *const t_digest )

static

Definition at line 743 of file ResultSet.cpp.

References CHECK, quantile::detail::TDigest< RealType, IndexType >::mergeBuffer(), NULL_DOUBLE, and quantile::detail::TDigest< RealType, IndexType >::quantile().

Referenced by makeTargetValue().

                                                                    {
   static_assert(sizeof(int64_t) == sizeof(quantile::TDigest*));
   CHECK(t_digest);
   t_digest->mergeBuffer();
   double const quantile = t_digest->quantile();
   return boost::math::isnan(quantile) ? NULL_DOUBLE : quantile;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool ResultSet::canUseFastBaselineSort	(	const std::list< Analyzer::OrderEntry > &	order_entries,
		const size_t	top_n
	)

private

size_t ResultSet::colCount ( ) const

Definition at line 275 of file ResultSet.cpp.

                                  {
   return just_explain_ ? 1 : targets_.size();
 }

void ResultSet::copyColumnIntoBuffer	(	const size_t	column_idx,
		int8_t *	output_buffer,
		const size_t	output_buffer_size
	)		const

For each specified column, this function goes through all available storages and copy its content into a contiguous output_buffer

Definition at line 1119 of file ResultSetIteration.cpp.

References appended_storage_, CHECK, CHECK_LT, QueryMemoryDescriptor::getPaddedSlotWidthBytes(), QueryMemoryDescriptor::getSlotCount(), i, isDirectColumnarConversionPossible(), query_mem_desc_, and storage_.

                                                                             {
   CHECK(isDirectColumnarConversionPossible());
   CHECK_LT(column_idx, query_mem_desc_.getSlotCount());
   CHECK(output_buffer_size > 0);
   CHECK(output_buffer);
   const auto column_width_size = query_mem_desc_.getPaddedSlotWidthBytes(column_idx);
   size_t out_buff_offset = 0;
 
   // the main storage:
   const size_t crt_storage_row_count = storage_->query_mem_desc_.getEntryCount();
   const size_t crt_buffer_size = crt_storage_row_count * column_width_size;
   const size_t column_offset = storage_->query_mem_desc_.getColOffInBytes(column_idx);
   const int8_t* storage_buffer = storage_->getUnderlyingBuffer() + column_offset;
   CHECK(crt_buffer_size <= output_buffer_size);
   std::memcpy(output_buffer, storage_buffer, crt_buffer_size);
 
   out_buff_offset += crt_buffer_size;
 
   // the appended storages:
   for (size_t i = 0; i < appended_storage_.size(); i++) {
     const size_t crt_storage_row_count =
         appended_storage_[i]->query_mem_desc_.getEntryCount();
     if (crt_storage_row_count == 0) {
       // skip an empty appended storage
       continue;
     }
     CHECK_LT(out_buff_offset, output_buffer_size);
     const size_t crt_buffer_size = crt_storage_row_count * column_width_size;
     const size_t column_offset =
         appended_storage_[i]->query_mem_desc_.getColOffInBytes(column_idx);
     const int8_t* storage_buffer =
         appended_storage_[i]->getUnderlyingBuffer() + column_offset;
     CHECK(out_buff_offset + crt_buffer_size <= output_buffer_size);
     std::memcpy(output_buffer + out_buff_offset, storage_buffer, crt_buffer_size);
 
     out_buff_offset += crt_buffer_size;
   }
 }

Here is the call graph for this function:

void ResultSet::create_active_buffer_set ( BufferSet & count_distinct_active_buffer_set ) const

private

Comparator ResultSet::createComparator	(	const std::list< Analyzer::OrderEntry > &	order_entries,
		const PermutationView	permutation,
		const Executor *	executor,
		const bool	single_threaded
	)

inlineprivate

Definition at line 674 of file ResultSet.h.

References DEBUG_TIMER, QueryMemoryDescriptor::didOutputColumnar(), and query_mem_desc_.

                                                           {
     auto timer = DEBUG_TIMER(__func__);
     if (query_mem_desc_.didOutputColumnar()) {
       return [rsc = ResultSetComparator<ColumnWiseTargetAccessor>(
                   order_entries, this, permutation, executor, single_threaded)](
                  const PermutationIdx lhs, const PermutationIdx rhs) {
         return rsc(lhs, rhs);
       };
     } else {
       return [rsc = ResultSetComparator<RowWiseTargetAccessor>(
                   order_entries, this, permutation, executor, single_threaded)](
                  const PermutationIdx lhs, const PermutationIdx rhs) {
         return rsc(lhs, rhs);
       };
     }
   }

Here is the call graph for this function:

bool ResultSet::definitelyHasNoRows ( ) const

Definition at line 404 of file ResultSet.cpp.

                                           {
   return !storage_ && !estimator_ && !just_explain_;
 }

bool ResultSet::didOutputColumnar ( ) const

inline

Definition at line 407 of file ResultSet.h.

References QueryMemoryDescriptor::didOutputColumnar(), and query_mem_desc_.

407 { return this->query_mem_desc_.didOutputColumnar(); }

ResultSet::query_mem_desc_

QueryMemoryDescriptor query_mem_desc_

Definition: ResultSet.h:741

QueryMemoryDescriptor::didOutputColumnar

bool didOutputColumnar() const

Definition: QueryMemoryDescriptor.h:265

Here is the call graph for this function:

void ResultSet::doBaselineSort	(	const ExecutorDeviceType	device_type,
		const std::list< Analyzer::OrderEntry > &	order_entries,
		const size_t	top_n,
		const Executor *	executor
	)

private

void ResultSet::dropFirstN ( const size_t n )

Definition at line 52 of file ResultSet.cpp.

References CHECK_EQ, and anonymous_namespace{Utm.h}::n.

                                          {
   CHECK_EQ(-1, cached_row_count_);
   drop_first_ = n;
 }

size_t ResultSet::entryCount ( ) const

Returns the count of entries we allocated for the result set to hold. Note that this is not representative of the number of rows in the result set.

More concretely: entryCount() > 0 does not imply the result set is not empty. For an empty check, use isEmpty

Definition at line 750 of file ResultSetIteration.cpp.

References QueryMemoryDescriptor::getEntryCount(), permutation_, and query_mem_desc_.

                                    {
   return permutation_.empty() ? query_mem_desc_.getEntryCount() : permutation_.size();
 }

Here is the call graph for this function:

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

inline

Definition at line 351 of file ResultSet.h.

References CHECK, and storage_.

                                                      {
     CHECK(storage_);
     if (storage_->query_mem_desc_.didOutputColumnar()) {
       storage_->fillOneEntryColWise(entry);
     } else {
       storage_->fillOneEntryRowWise(entry);
     }
   }

ResultSet::StorageLookupResult ResultSet::findStorage ( const size_t entry_idx ) const

private

Definition at line 674 of file ResultSet.cpp.

Referenced by getVarlenOutputInfo(), and makeGeoTargetValue().

                                                                                 {
   auto [stg_idx, fixedup_entry_idx] = getStorageIndex(entry_idx);
   return {stg_idx ? appended_storage_[stg_idx - 1].get() : storage_.get(),
           fixedup_entry_idx,
           stg_idx};
 }

Here is the caller graph for this function:

void ResultSet::fixupCountDistinctPointers ( )

private

QueryMemoryDescriptor ResultSet::fixupQueryMemoryDescriptor ( const QueryMemoryDescriptor & query_mem_desc )

static

Definition at line 491 of file ResultSet.cpp.

References QueryMemoryDescriptor::didOutputColumnar(), and query_mem_desc.

Referenced by GpuSharedMemCodeBuilder::codegenInitialization(), GpuSharedMemCodeBuilder::codegenReduction(), Executor::executeTableFunction(), QueryExecutionContext::groupBufferToDeinterleavedResults(), QueryMemoryInitializer::initRowGroups(), QueryMemoryInitializer::QueryMemoryInitializer(), and Executor::reduceMultiDeviceResults().

                                                  {
   auto query_mem_desc_copy = query_mem_desc;
   query_mem_desc_copy.resetGroupColWidths(
       std::vector<int8_t>(query_mem_desc_copy.getGroupbyColCount(), 8));
   if (query_mem_desc.didOutputColumnar()) {
     return query_mem_desc_copy;
   }
   query_mem_desc_copy.alignPaddedSlots();
   return query_mem_desc_copy;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t ResultSet::getBufferSizeBytes ( const ExecutorDeviceType device_type ) const

Definition at line 754 of file ResultSetIteration.cpp.

References CHECK, and storage_.

                                                                                {
   CHECK(storage_);
   return storage_->query_mem_desc_.getBufferSizeBytes(device_type);
 }

SQLTypeInfo ResultSet::getColType ( const size_t col_idx ) const

Definition at line 279 of file ResultSet.cpp.

References CHECK_LT, kAVG, kDOUBLE, and kTEXT.

                                                             {
   if (just_explain_) {
     return SQLTypeInfo(kTEXT, false);
   }
   CHECK_LT(col_idx, targets_.size());
   return targets_[col_idx].agg_kind == kAVG ? SQLTypeInfo(kDOUBLE, false)
                                             : targets_[col_idx].sql_type;
 }

template<typename ENTRY_TYPE >

ENTRY_TYPE ResultSet::getColumnarBaselineEntryAt	(	const size_t	row_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)		const

private

template<typename ENTRY_TYPE >

ENTRY_TYPE ResultSet::getColumnarBaselineEntryAt	(	const size_t	row_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)		const

Directly accesses the result set's storage buffer for a particular data type (row-wise output, baseline hash group by)

NOTE: Currently, only used in direct columnarization

Definition at line 1291 of file ResultSetIteration.cpp.

References CHECK_NE, and storage_.

                                                                               {
   CHECK_NE(storage_->query_mem_desc_.targetGroupbyIndicesSize(), size_t(0));
   const auto key_width = storage_->query_mem_desc_.getEffectiveKeyWidth();
   const auto column_offset =
       (storage_->query_mem_desc_.getTargetGroupbyIndex(target_idx) < 0)
           ? storage_->query_mem_desc_.getColOffInBytes(slot_idx)
           : storage_->query_mem_desc_.getTargetGroupbyIndex(target_idx) * key_width *
                 storage_->query_mem_desc_.getEntryCount();
   const auto column_buffer = storage_->getUnderlyingBuffer() + column_offset;
   return reinterpret_cast<const ENTRY_TYPE*>(column_buffer)[row_idx];
 }

const int8_t * ResultSet::getColumnarBuffer ( size_t column_idx ) const

Definition at line 1074 of file ResultSet.cpp.

References CHECK.

                                                                   {
   CHECK(isZeroCopyColumnarConversionPossible(column_idx));
   return storage_->getUnderlyingBuffer() + query_mem_desc_.getColOffInBytes(column_idx);
 }

template<typename ENTRY_TYPE >

ENTRY_TYPE ResultSet::getColumnarPerfectHashEntryAt	(	const size_t	row_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)		const

private

template<typename ENTRY_TYPE >

ENTRY_TYPE ResultSet::getColumnarPerfectHashEntryAt	(	const size_t	row_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)		const

Directly accesses the result set's storage buffer for a particular data type (columnar output, perfect hash group by)

NOTE: Currently, only used in direct columnarization

Definition at line 1237 of file ResultSetIteration.cpp.

References storage_.

                                                                                  {
   const size_t column_offset = storage_->query_mem_desc_.getColOffInBytes(slot_idx);
   const int8_t* storage_buffer = storage_->getUnderlyingBuffer() + column_offset;
   return reinterpret_cast<const ENTRY_TYPE*>(storage_buffer)[row_idx];
 }

const std::vector< const int8_t * > & ResultSet::getColumnFrag	(	const size_t	storge_idx,
		const size_t	col_logical_idx,
		int64_t &	global_idx
	)		const

private

Definition at line 1084 of file ResultSetIteration.cpp.

References CHECK_EQ, CHECK_GE, CHECK_LE, CHECK_LT, col_buffers_, consistent_frag_sizes_, frag_offsets_, and anonymous_namespace{ResultSetIteration.cpp}::get_frag_id_and_local_idx().

Referenced by lazyReadInt(), makeGeoTargetValue(), makeTargetValue(), and makeVarlenTargetValue().

                                                                                       {
   CHECK_LT(static_cast<size_t>(storage_idx), col_buffers_.size());
   if (col_buffers_[storage_idx].size() > 1) {
     int64_t frag_id = 0;
     int64_t local_idx = global_idx;
     if (consistent_frag_sizes_[storage_idx][col_logical_idx] != -1) {
       frag_id = global_idx / consistent_frag_sizes_[storage_idx][col_logical_idx];
       local_idx = global_idx % consistent_frag_sizes_[storage_idx][col_logical_idx];
     } else {
       std::tie(frag_id, local_idx) = get_frag_id_and_local_idx(
           frag_offsets_[storage_idx], col_logical_idx, global_idx);
       CHECK_LE(local_idx, global_idx);
     }
     CHECK_GE(frag_id, int64_t(0));
     CHECK_LT(static_cast<size_t>(frag_id), col_buffers_[storage_idx].size());
     global_idx = local_idx;
     return col_buffers_[storage_idx][frag_id];
   } else {
     CHECK_EQ(size_t(1), col_buffers_[storage_idx].size());
     return col_buffers_[storage_idx][0];
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t ResultSet::getCurrentRowBufferIndex ( ) const

Definition at line 233 of file ResultSet.cpp.

                                                  {
   if (crt_row_buff_idx_ == 0) {
     throw std::runtime_error("current row buffer iteration index is undefined");
   }
   return crt_row_buff_idx_ - 1;
 }

Data_Namespace::DataMgr* ResultSet::getDataManager ( ) const

private

int8_t * ResultSet::getDeviceEstimatorBuffer ( ) const

Definition at line 422 of file ResultSet.cpp.

References CHECK, and GPU.

                                                   {
   CHECK(device_type_ == ExecutorDeviceType::GPU);
   CHECK(device_estimator_buffer_);
   return device_estimator_buffer_->getMemoryPtr();
 }

int ResultSet::getDeviceId ( ) const

Definition at line 487 of file ResultSet.cpp.

                                  {
   return device_id_;
 }

ExecutorDeviceType ResultSet::getDeviceType ( ) const

Definition at line 192 of file ResultSet.cpp.

                                                   {
   return device_type_;
 }

int64_t ResultSet::getDistinctBufferRefFromBufferRowwise	(	int8_t *	rowwise_target_ptr,
		const TargetInfo &	target_info
	)		const

private

template<typename ENTRY_TYPE , QueryDescriptionType QUERY_TYPE, bool COLUMNAR_FORMAT>

ENTRY_TYPE ResultSet::getEntryAt	(	const size_t	row_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)		const

template<typename ENTRY_TYPE , QueryDescriptionType QUERY_TYPE, bool COLUMNAR_FORMAT>

ENTRY_TYPE ResultSet::getEntryAt	(	const size_t	row_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)		const

Definition at line 1161 of file ResultSetIteration.cpp.

References GroupByBaselineHash, GroupByPerfectHash, and UNREACHABLE.

                                                               {
   if constexpr (QUERY_TYPE == QueryDescriptionType::GroupByPerfectHash) {  // NOLINT
     if constexpr (COLUMNAR_FORMAT) {                                       // NOLINT
       return getColumnarPerfectHashEntryAt<ENTRY_TYPE>(row_idx, target_idx, slot_idx);
     } else {
       return getRowWisePerfectHashEntryAt<ENTRY_TYPE>(row_idx, target_idx, slot_idx);
     }
   } else if constexpr (QUERY_TYPE == QueryDescriptionType::GroupByBaselineHash) {
     if constexpr (COLUMNAR_FORMAT) {  // NOLINT
       return getColumnarBaselineEntryAt<ENTRY_TYPE>(row_idx, target_idx, slot_idx);
     } else {
       return getRowWiseBaselineEntryAt<ENTRY_TYPE>(row_idx, target_idx, slot_idx);
     }
   } else {
     UNREACHABLE() << "Invalid query type is used";
     return 0;
   }
 }

std::string ResultSet::getExplanation ( ) const

inline

Definition at line 336 of file ResultSet.h.

References explanation_, and just_explain_.

                                    {
     if (just_explain_) {
       return explanation_;
     }
     return {};
   }

GeoReturnType ResultSet::getGeoReturnType ( ) const

inline

Definition at line 398 of file ResultSet.h.

References geo_return_type_.

398 { return geo_return_type_; }

ResultSet::geo_return_type_

GeoReturnType geo_return_type_

Definition: ResultSet.h:783

int ResultSet::getGpuCount ( ) const

private

int8_t * ResultSet::getHostEstimatorBuffer ( ) const

Definition at line 428 of file ResultSet.cpp.

                                                 {
   return host_estimator_buffer_;
 }

const std::vector<ColumnLazyFetchInfo>& ResultSet::getLazyFetchInfo ( ) const

inline

Definition at line 427 of file ResultSet.h.

References lazy_fetch_info_.

                                                                  {
     return lazy_fetch_info_;
   }

size_t ResultSet::getLimit ( ) const

Definition at line 1030 of file ResultSet.cpp.

                                  {
   return keep_first_;
 }

size_t ResultSet::getNDVEstimator ( ) const

Definition at line 33 of file CardinalityEstimator.cpp.

References bitmap_set_size(), CHECK, CHECK_LE, LOG, and logger::WARNING.

                                         {
   CHECK(dynamic_cast<const Analyzer::NDVEstimator*>(estimator_.get()));
   CHECK(host_estimator_buffer_);
   auto bits_set = bitmap_set_size(host_estimator_buffer_, estimator_->getBufferSize());
   if (bits_set == 0) {
     // empty result set, return 1 for a groups buffer size of 1
     return 1;
   }
   const auto total_bits = estimator_->getBufferSize() * 8;
   CHECK_LE(bits_set, total_bits);
   const auto unset_bits = total_bits - bits_set;
   const auto ratio = static_cast<double>(unset_bits) / total_bits;
   if (ratio == 0.) {
     LOG(WARNING)
         << "Failed to get a high quality cardinality estimation, falling back to "
            "approximate group by buffer size guess.";
     return 0;
   }
   return -static_cast<double>(total_bits) * log(ratio);
 }

Here is the call graph for this function:

std::vector< TargetValue > ResultSet::getNextRow	(	const bool	translate_strings,
		const bool	decimal_to_double
	)		const

Definition at line 297 of file ResultSetIteration.cpp.

                                                                                    {
   std::lock_guard<std::mutex> lock(row_iteration_mutex_);
   if (!storage_ && !just_explain_) {
     return {};
   }
   return getNextRowUnlocked(translate_strings, decimal_to_double);
 }

std::vector< TargetValue > ResultSet::getNextRowImpl	(	const bool	translate_strings,
		const bool	decimal_to_double
	)		const

private

Definition at line 319 of file ResultSetIteration.cpp.

References CHECK, and CHECK_EQ.

                                                                                        {
   size_t entry_buff_idx = 0;
   do {
     if (keep_first_ && fetched_so_far_ >= drop_first_ + keep_first_) {
       return {};
     }
 
     entry_buff_idx = advanceCursorToNextEntry();
 
     if (crt_row_buff_idx_ >= entryCount()) {
       CHECK_EQ(entryCount(), crt_row_buff_idx_);
       return {};
     }
     ++crt_row_buff_idx_;
     ++fetched_so_far_;
 
   } while (drop_first_ && fetched_so_far_ <= drop_first_);
 
   auto row = getRowAt(entry_buff_idx, translate_strings, decimal_to_double, false);
   CHECK(!row.empty());
 
   return row;
 }

std::vector< TargetValue > ResultSet::getNextRowUnlocked	(	const bool	translate_strings,
		const bool	decimal_to_double
	)		const

private

Definition at line 306 of file ResultSetIteration.cpp.

                                         {
   if (just_explain_) {
     if (fetched_so_far_) {
       return {};
     }
     fetched_so_far_ = 1;
     return {explanation_};
   }
   return getNextRowImpl(translate_strings, decimal_to_double);
 }

OneIntegerColumnRow ResultSet::getOneColRow ( const size_t index ) const

Definition at line 235 of file ResultSetIteration.cpp.

References align_to_int64(), CHECK, get_key_bytes_rowwise(), and row_ptr_rowwise().

                                                                                {
   const auto storage_lookup_result = findStorage(global_entry_idx);
   const auto storage = storage_lookup_result.storage_ptr;
   const auto local_entry_idx = storage_lookup_result.fixedup_entry_idx;
   if (storage->isEmptyEntry(local_entry_idx)) {
     return {0, false};
   }
   const auto buff = storage->buff_;
   CHECK(buff);
   CHECK(!query_mem_desc_.didOutputColumnar());
   const auto keys_ptr = row_ptr_rowwise(buff, query_mem_desc_, local_entry_idx);
   const auto key_bytes_with_padding =
       align_to_int64(get_key_bytes_rowwise(query_mem_desc_));
   const auto rowwise_target_ptr = keys_ptr + key_bytes_with_padding;
   const auto tv = getTargetValueFromBufferRowwise(rowwise_target_ptr,
                                                   keys_ptr,
                                                   global_entry_idx,
                                                   targets_.front(),
                                                   0,
                                                   0,
                                                   false,
                                                   false,
                                                   false);
   const auto scalar_tv = boost::get<ScalarTargetValue>(&tv);
   CHECK(scalar_tv);
   const auto ival_ptr = boost::get<int64_t>(scalar_tv);
   CHECK(ival_ptr);
   return {*ival_ptr, true};
 }

Here is the call graph for this function:

const int8_t ResultSet::getPaddedSlotWidthBytes ( const size_t slot_idx ) const

inline

Definition at line 416 of file ResultSet.h.

References QueryMemoryDescriptor::getPaddedSlotWidthBytes(), and query_mem_desc_.

                                                                     {
     return query_mem_desc_.getPaddedSlotWidthBytes(slot_idx);
   }

Here is the call graph for this function:

const Permutation & ResultSet::getPermutationBuffer ( ) const

Definition at line 597 of file ResultSet.cpp.

                                                          {
   return permutation_;
 }

QueryDescriptionType ResultSet::getQueryDescriptionType ( ) const

inline

Definition at line 412 of file ResultSet.h.

References QueryMemoryDescriptor::getQueryDescriptionType(), and query_mem_desc_.

                                                        {
     return query_mem_desc_.getQueryDescriptionType();
   }

Here is the call graph for this function:

const QueryMemoryDescriptor & ResultSet::getQueryMemDesc ( ) const

Definition at line 408 of file ResultSet.cpp.

References CHECK.

                                                               {
   CHECK(storage_);
   return storage_->query_mem_desc_;
 }

int64_t ResultSet::getQueueTime ( ) const

Definition at line 457 of file ResultSet.cpp.

                                       {
   return timings_.executor_queue_time + timings_.kernel_queue_time +
          timings_.compilation_queue_time;
 }

int64_t ResultSet::getRenderTime ( ) const

Definition at line 462 of file ResultSet.cpp.

                                        {
   return timings_.render_time;
 }

std::vector<TargetValue> ResultSet::getRowAt ( const size_t index ) const

TargetValue ResultSet::getRowAt	(	const size_t	row_idx,
		const size_t	col_idx,
		const bool	translate_strings,
		const bool	decimal_to_double = `true`
	)		const

std::vector<TargetValue> ResultSet::getRowAt	(	const size_t	index,
		const bool	translate_strings,
		const bool	decimal_to_double,
		const bool	fixup_count_distinct_pointers,
		const std::vector< bool > &	targets_to_skip = `{}`
	)		const

private

std::vector< TargetValue > ResultSet::getRowAtNoTranslations	(	const size_t	index,
		const std::vector< bool > &	targets_to_skip = `{}`
	)		const

Definition at line 274 of file ResultSetIteration.cpp.

                                                     {
   if (logical_index >= entryCount()) {
     return {};
   }
   const auto entry_idx =
       permutation_.empty() ? logical_index : permutation_[logical_index];
   return getRowAt(entry_idx, false, false, false, targets_to_skip);
 }

std::shared_ptr<RowSetMemoryOwner> ResultSet::getRowSetMemOwner ( ) const

inline

Definition at line 372 of file ResultSet.h.

References row_set_mem_owner_.

                                                              {
     return row_set_mem_owner_;
   }

template<typename ENTRY_TYPE >

ENTRY_TYPE ResultSet::getRowWiseBaselineEntryAt	(	const size_t	row_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)		const

private

template<typename ENTRY_TYPE >

ENTRY_TYPE ResultSet::getRowWiseBaselineEntryAt	(	const size_t	row_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)		const

Directly accesses the result set's storage buffer for a particular data type (columnar output, baseline hash group by)

NOTE: Currently, only used in direct columnarization

Definition at line 1269 of file ResultSetIteration.cpp.

References CHECK_NE, row_ptr_rowwise(), and storage_.

                                                                              {
   CHECK_NE(storage_->query_mem_desc_.targetGroupbyIndicesSize(), size_t(0));
   const auto key_width = storage_->query_mem_desc_.getEffectiveKeyWidth();
   auto keys_ptr = row_ptr_rowwise(
       storage_->getUnderlyingBuffer(), storage_->query_mem_desc_, row_idx);
   const auto column_offset =
       (storage_->query_mem_desc_.getTargetGroupbyIndex(target_idx) < 0)
           ? storage_->query_mem_desc_.getColOffInBytes(slot_idx)
           : storage_->query_mem_desc_.getTargetGroupbyIndex(target_idx) * key_width;
   const auto storage_buffer = keys_ptr + column_offset;
   return *reinterpret_cast<const ENTRY_TYPE*>(storage_buffer);
 }

Here is the call graph for this function:

template<typename ENTRY_TYPE >

ENTRY_TYPE ResultSet::getRowWisePerfectHashEntryAt	(	const size_t	row_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)		const

private

template<typename ENTRY_TYPE >

ENTRY_TYPE ResultSet::getRowWisePerfectHashEntryAt	(	const size_t	row_idx,
		const size_t	target_idx,
		const size_t	slot_idx
	)		const

Directly accesses the result set's storage buffer for a particular data type (row-wise output, perfect hash group by)

NOTE: Currently, only used in direct columnarization

Definition at line 1252 of file ResultSetIteration.cpp.

References storage_.

                                                                                 {
   const size_t row_offset = storage_->query_mem_desc_.getRowSize() * row_idx;
   const size_t column_offset = storage_->query_mem_desc_.getColOffInBytes(slot_idx);
   const int8_t* storage_buffer =
       storage_->getUnderlyingBuffer() + row_offset + column_offset;
   return *reinterpret_cast<const ENTRY_TYPE*>(storage_buffer);
 }

std::tuple< std::vector< bool >, size_t > ResultSet::getSingleSlotTargetBitmap ( ) const

Definition at line 1080 of file ResultSet.cpp.

References anonymous_namespace{RelAlgExecutor.cpp}::is_agg(), and kAVG.

                                                                              {
   std::vector<bool> target_bitmap(targets_.size(), true);
   size_t num_single_slot_targets = 0;
   for (size_t target_idx = 0; target_idx < targets_.size(); target_idx++) {
     const auto& sql_type = targets_[target_idx].sql_type;
     if (targets_[target_idx].is_agg && targets_[target_idx].agg_kind == kAVG) {
       target_bitmap[target_idx] = false;
     } else if (sql_type.is_varlen()) {
       target_bitmap[target_idx] = false;
     } else {
       num_single_slot_targets++;
     }
   }
   return std::make_tuple(std::move(target_bitmap), num_single_slot_targets);
 }

Here is the call graph for this function:

std::vector< size_t > ResultSet::getSlotIndicesForTargetIndices ( ) const

Definition at line 1123 of file ResultSet.cpp.

References advance_slot().

                                                                   {
   std::vector<size_t> slot_indices(targets_.size(), 0);
   size_t slot_index = 0;
   for (size_t target_idx = 0; target_idx < targets_.size(); target_idx++) {
     slot_indices[target_idx] = slot_index;
     slot_index = advance_slot(slot_index, targets_[target_idx], false);
   }
   return slot_indices;
 }

Here is the call graph for this function:

const ResultSetStorage * ResultSet::getStorage ( ) const

Definition at line 271 of file ResultSet.cpp.

                                                     {
   return storage_.get();
 }

std::pair< size_t, size_t > ResultSet::getStorageIndex ( const size_t entry_idx ) const

private

Returns (storageIdx, entryIdx) pair, where: storageIdx : 0 is storage_, storageIdx-1 is index into appended_storage_. entryIdx : local index into the storage object.

Definition at line 649 of file ResultSet.cpp.

References CHECK_NE, i, and UNREACHABLE.

Referenced by makeGeoTargetValue(), makeTargetValue(), and makeVarlenTargetValue().

                                                                                {
   size_t fixedup_entry_idx = entry_idx;
   auto entry_count = storage_->query_mem_desc_.getEntryCount();
   const bool is_rowwise_layout = !storage_->query_mem_desc_.didOutputColumnar();
   if (fixedup_entry_idx < entry_count) {
     return {0, fixedup_entry_idx};
   }
   fixedup_entry_idx -= entry_count;
   for (size_t i = 0; i < appended_storage_.size(); ++i) {
     const auto& desc = appended_storage_[i]->query_mem_desc_;
     CHECK_NE(is_rowwise_layout, desc.didOutputColumnar());
     entry_count = desc.getEntryCount();
     if (fixedup_entry_idx < entry_count) {
       return {i + 1, fixedup_entry_idx};
     }
     fixedup_entry_idx -= entry_count;
   }
   UNREACHABLE() << "entry_idx = " << entry_idx << ", query_mem_desc_.getEntryCount() = "
                 << query_mem_desc_.getEntryCount();
   return {};
 }

Here is the caller graph for this function:

std::shared_ptr< const std::vector< std::string > > ResultSet::getStringDictionaryPayloadCopy ( const int dict_id ) const

Definition at line 1034 of file ResultSet.cpp.

References catalog_(), and CHECK.

                              {
   const auto sdp = row_set_mem_owner_->getOrAddStringDictProxy(
       dict_id, /*with_generation=*/false, catalog_);
   CHECK(sdp);
   return sdp->getDictionary()->copyStrings();
 }

Here is the call graph for this function:

std::tuple< std::vector< bool >, size_t > ResultSet::getSupportedSingleSlotTargetBitmap ( ) const

This function returns a bitmap and population count of it, where it denotes all supported single-column targets suitable for direct columnarization.

The final goal is to remove the need for such selection, but at the moment for any target that doesn't qualify for direct columnarization, we use the traditional result set's iteration to handle it (e.g., count distinct, approximate count distinct)

Definition at line 1104 of file ResultSet.cpp.

References CHECK, CHECK_GE, is_distinct_target(), kAPPROX_QUANTILE, kFLOAT, and kSAMPLE.

           {
   CHECK(isDirectColumnarConversionPossible());
   auto [single_slot_targets, num_single_slot_targets] = getSingleSlotTargetBitmap();
 
   for (size_t target_idx = 0; target_idx < single_slot_targets.size(); target_idx++) {
     const auto& target = targets_[target_idx];
     if (single_slot_targets[target_idx] &&
         (is_distinct_target(target) || target.agg_kind == kAPPROX_QUANTILE ||
          (target.is_agg && target.agg_kind == kSAMPLE && target.sql_type == kFLOAT))) {
       single_slot_targets[target_idx] = false;
       num_single_slot_targets--;
     }
   }
   CHECK_GE(num_single_slot_targets, size_t(0));
   return std::make_tuple(std::move(single_slot_targets), num_single_slot_targets);
 }

Here is the call graph for this function:

const std::vector< TargetInfo > & ResultSet::getTargetInfos ( ) const

Definition at line 413 of file ResultSet.cpp.

                                                              {
   return targets_;
 }

const std::vector< int64_t > & ResultSet::getTargetInitVals ( ) const

Definition at line 417 of file ResultSet.cpp.

References CHECK.

                                                              {
   CHECK(storage_);
   return storage_->target_init_vals_;
 }

TargetValue ResultSet::getTargetValueFromBufferColwise	(	const int8_t *	col_ptr,
		const int8_t *	keys_ptr,
		const QueryMemoryDescriptor &	query_mem_desc,
		const size_t	local_entry_idx,
		const size_t	global_entry_idx,
		const TargetInfo &	target_info,
		const size_t	target_logical_idx,
		const size_t	slot_idx,
		const bool	translate_strings,
		const bool	decimal_to_double
	)		const

private

Definition at line 1882 of file ResultSetIteration.cpp.

References advance_to_next_columnar_target_buff(), TargetInfo::agg_kind, CHECK, CHECK_GE, anonymous_namespace{ResultSetIteration.cpp}::columnar_elem_ptr(), QueryMemoryDescriptor::didOutputColumnar(), QueryMemoryDescriptor::getEffectiveKeyWidth(), QueryMemoryDescriptor::getEntryCount(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), QueryMemoryDescriptor::getTargetGroupbyIndex(), TargetInfo::is_agg, SQLTypeInfo::is_geometry(), is_real_str_or_array(), kAVG, anonymous_namespace{ResultSetIteration.cpp}::make_avg_target_value(), makeGeoTargetValue(), makeTargetValue(), makeVarlenTargetValue(), query_mem_desc_, TargetInfo::sql_type, and QueryMemoryDescriptor::targetGroupbyIndicesSize().

                                         {
   CHECK(query_mem_desc_.didOutputColumnar());
   const auto col1_ptr = col_ptr;
   const auto compact_sz1 = query_mem_desc.getPaddedSlotWidthBytes(slot_idx);
   const auto next_col_ptr =
       advance_to_next_columnar_target_buff(col1_ptr, query_mem_desc, slot_idx);
   const auto col2_ptr = ((target_info.is_agg && target_info.agg_kind == kAVG) ||
                          is_real_str_or_array(target_info))
                             ? next_col_ptr
                             : nullptr;
   const auto compact_sz2 = ((target_info.is_agg && target_info.agg_kind == kAVG) ||
                             is_real_str_or_array(target_info))
                                ? query_mem_desc.getPaddedSlotWidthBytes(slot_idx + 1)
                                : 0;
 
   // TODO(Saman): add required logics for count distinct
   // geospatial target values:
   if (target_info.sql_type.is_geometry()) {
     return makeGeoTargetValue(
         col1_ptr, slot_idx, target_info, target_logical_idx, global_entry_idx);
   }
 
   const auto ptr1 = columnar_elem_ptr(local_entry_idx, col1_ptr, compact_sz1);
   if (target_info.agg_kind == kAVG || is_real_str_or_array(target_info)) {
     CHECK(col2_ptr);
     CHECK(compact_sz2);
     const auto ptr2 = columnar_elem_ptr(local_entry_idx, col2_ptr, compact_sz2);
     return target_info.agg_kind == kAVG
                ? make_avg_target_value(ptr1, compact_sz1, ptr2, compact_sz2, target_info)
                : makeVarlenTargetValue(ptr1,
                                        compact_sz1,
                                        ptr2,
                                        compact_sz2,
                                        target_info,
                                        target_logical_idx,
                                        translate_strings,
                                        global_entry_idx);
   }
   if (query_mem_desc_.targetGroupbyIndicesSize() == 0 ||
       query_mem_desc_.getTargetGroupbyIndex(target_logical_idx) < 0) {
     return makeTargetValue(ptr1,
                            compact_sz1,
                            target_info,
                            target_logical_idx,
                            translate_strings,
                            decimal_to_double,
                            global_entry_idx);
   }
   const auto key_width = query_mem_desc_.getEffectiveKeyWidth();
   const auto key_idx = query_mem_desc_.getTargetGroupbyIndex(target_logical_idx);
   CHECK_GE(key_idx, 0);
   auto key_col_ptr = keys_ptr + key_idx * query_mem_desc_.getEntryCount() * key_width;
   return makeTargetValue(columnar_elem_ptr(local_entry_idx, key_col_ptr, key_width),
                          key_width,
                          target_info,
                          target_logical_idx,
                          translate_strings,
                          decimal_to_double,
                          global_entry_idx);
 }

Here is the call graph for this function:

TargetValue ResultSet::getTargetValueFromBufferRowwise	(	int8_t *	rowwise_target_ptr,
		int8_t *	keys_ptr,
		const size_t	entry_buff_idx,
		const TargetInfo &	target_info,
		const size_t	target_logical_idx,
		const size_t	slot_idx,
		const bool	translate_strings,
		const bool	decimal_to_double,
		const bool	fixup_count_distinct_pointers
	)		const

private

Definition at line 1955 of file ResultSetIteration.cpp.

                                                     {
   if (UNLIKELY(fixup_count_distinct_pointers)) {
     if (is_distinct_target(target_info)) {
       auto count_distinct_ptr_ptr = reinterpret_cast<int64_t*>(rowwise_target_ptr);
       const auto remote_ptr = *count_distinct_ptr_ptr;
       if (remote_ptr) {
         const auto ptr = storage_->mappedPtr(remote_ptr);
         if (ptr) {
           *count_distinct_ptr_ptr = ptr;
         } else {
           // need to create a zero filled buffer for this remote_ptr
           const auto& count_distinct_desc =
               query_mem_desc_.count_distinct_descriptors_[target_logical_idx];
           const auto bitmap_byte_sz = count_distinct_desc.sub_bitmap_count == 1
                                           ? count_distinct_desc.bitmapSizeBytes()
                                           : count_distinct_desc.bitmapPaddedSizeBytes();
           auto count_distinct_buffer = row_set_mem_owner_->allocateCountDistinctBuffer(
               bitmap_byte_sz, /*thread_idx=*/0);
           *count_distinct_ptr_ptr = reinterpret_cast<int64_t>(count_distinct_buffer);
         }
       }
     }
     return int64_t(0);
   }
   if (target_info.sql_type.is_geometry()) {
     return makeGeoTargetValue(
         rowwise_target_ptr, slot_idx, target_info, target_logical_idx, entry_buff_idx);
   }
 
   auto ptr1 = rowwise_target_ptr;
   int8_t compact_sz1 = query_mem_desc_.getPaddedSlotWidthBytes(slot_idx);
   if (query_mem_desc_.isSingleColumnGroupByWithPerfectHash() &&
       !query_mem_desc_.hasKeylessHash() && !target_info.is_agg) {
     // Single column perfect hash group by can utilize one slot for both the key and the
     // target value if both values fit in 8 bytes. Use the target value actual size for
     // this case. If they don't, the target value should be 8 bytes, so we can still use
     // the actual size rather than the compact size.
     compact_sz1 = query_mem_desc_.getLogicalSlotWidthBytes(slot_idx);
   }
 
   // logic for deciding width of column
   if (target_info.agg_kind == kAVG || is_real_str_or_array(target_info)) {
     const auto ptr2 =
         rowwise_target_ptr + query_mem_desc_.getPaddedSlotWidthBytes(slot_idx);
     int8_t compact_sz2 = 0;
     // Skip reading the second slot if we have a none encoded string and are using
     // the none encoded strings buffer attached to ResultSetStorage
     if (!(separate_varlen_storage_valid_ &&
           (target_info.sql_type.is_array() ||
            (target_info.sql_type.is_string() &&
             target_info.sql_type.get_compression() == kENCODING_NONE)))) {
       compact_sz2 = query_mem_desc_.getPaddedSlotWidthBytes(slot_idx + 1);
     }
     if (separate_varlen_storage_valid_ && target_info.is_agg) {
       compact_sz2 = 8;  // TODO(adb): is there a better way to do this?
     }
     CHECK(ptr2);
     return target_info.agg_kind == kAVG
                ? make_avg_target_value(ptr1, compact_sz1, ptr2, compact_sz2, target_info)
                : makeVarlenTargetValue(ptr1,
                                        compact_sz1,
                                        ptr2,
                                        compact_sz2,
                                        target_info,
                                        target_logical_idx,
                                        translate_strings,
                                        entry_buff_idx);
   }
   if (query_mem_desc_.targetGroupbyIndicesSize() == 0 ||
       query_mem_desc_.getTargetGroupbyIndex(target_logical_idx) < 0) {
     return makeTargetValue(ptr1,
                            compact_sz1,
                            target_info,
                            target_logical_idx,
                            translate_strings,
                            decimal_to_double,
                            entry_buff_idx);
   }
   const auto key_width = query_mem_desc_.getEffectiveKeyWidth();
   ptr1 = keys_ptr + query_mem_desc_.getTargetGroupbyIndex(target_logical_idx) * key_width;
   return makeTargetValue(ptr1,
                          key_width,
                          target_info,
                          target_logical_idx,
                          translate_strings,
                          decimal_to_double,
                          entry_buff_idx);
 }

Here is the call graph for this function:

InternalTargetValue ResultSet::getVarlenOrderEntry	(	const int64_t	str_ptr,
		const size_t	str_len
	)		const

private

Definition at line 626 of file ResultSetIteration.cpp.

References CHECK, CPU, device_id_, device_type_, QueryMemoryDescriptor::getExecutor(), GPU, query_mem_desc_, and row_set_mem_owner_.

                                                                                {
   char* host_str_ptr{nullptr};
   std::vector<int8_t> cpu_buffer;
   if (device_type_ == ExecutorDeviceType::GPU) {
     cpu_buffer.resize(str_len);
     const auto executor = query_mem_desc_.getExecutor();
     CHECK(executor);
     auto data_mgr = executor->getDataMgr();
     auto allocator = data_mgr->createGpuAllocator(device_id_);
     allocator->copyFromDevice(
         &cpu_buffer[0], reinterpret_cast<int8_t*>(str_ptr), str_len);
     host_str_ptr = reinterpret_cast<char*>(&cpu_buffer[0]);
   } else {
     CHECK(device_type_ == ExecutorDeviceType::CPU);
     host_str_ptr = reinterpret_cast<char*>(str_ptr);
   }
   std::string str(host_str_ptr, str_len);
   return InternalTargetValue(row_set_mem_owner_->addString(str));
 }

Here is the call graph for this function:

const VarlenOutputInfo * ResultSet::getVarlenOutputInfo ( const size_t entry_idx ) const

private

Definition at line 1109 of file ResultSetIteration.cpp.

References CHECK, and findStorage().

Referenced by makeGeoTargetValue().

                                                                                    {
   auto storage_lookup_result = findStorage(entry_idx);
   CHECK(storage_lookup_result.storage_ptr);
   return storage_lookup_result.storage_ptr->getVarlenOutputInfo();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSet::holdChunkIterators ( const std::shared_ptr< std::list< ChunkIter >> chunk_iters )

inline

Definition at line 365 of file ResultSet.h.

References chunk_iters_.

                                                                                {
     chunk_iters_.push_back(chunk_iters);
   }

void ResultSet::holdChunks ( const std::list< std::shared_ptr< Chunk_NS::Chunk >> & chunks )

inline

Definition at line 362 of file ResultSet.h.

References chunks_.

                                                                        {
     chunks_ = chunks;
   }

void ResultSet::holdLiterals ( std::vector< int8_t > & literal_buff )

inline

Definition at line 368 of file ResultSet.h.

References literal_buffers_.

                                                      {
     literal_buffers_.push_back(std::move(literal_buff));
   }

void ResultSet::initializeStorage ( ) const

Definition at line 1044 of file ResultSetReduction.cpp.

                                         {
   if (query_mem_desc_.didOutputColumnar()) {
     storage_->initializeColWise();
   } else {
     storage_->initializeRowWise();
   }
 }

PermutationView ResultSet::initPermutationBuffer	(	PermutationView	permutation,
		PermutationIdx const	begin,
		PermutationIdx const	end
	)		const

private

Definition at line 581 of file ResultSet.cpp.

References CHECK, DEBUG_TIMER, i, and VectorView< T >::push_back().

                                                                                  {
   auto timer = DEBUG_TIMER(__func__);
   for (PermutationIdx i = begin; i < end; ++i) {
     const auto storage_lookup_result = findStorage(i);
     const auto lhs_storage = storage_lookup_result.storage_ptr;
     const auto off = storage_lookup_result.fixedup_entry_idx;
     CHECK(lhs_storage);
     if (!lhs_storage->isEmptyEntry(off)) {
       permutation.push_back(i);
     }
   }
   return permutation;
 }

Here is the call graph for this function:

bool ResultSet::isDirectColumnarConversionPossible ( ) const

Determines if it is possible to directly form a ColumnarResults class from this result set, bypassing the default columnarization.

NOTE: If there exists a permutation vector (i.e., in some ORDER BY queries), it becomes equivalent to the row-wise columnarization.

Definition at line 1049 of file ResultSet.cpp.

References g_enable_direct_columnarization, GroupByBaselineHash, GroupByPerfectHash, and Projection.

Referenced by copyColumnIntoBuffer().

                                                          {
   if (!g_enable_direct_columnarization) {
     return false;
   } else if (query_mem_desc_.didOutputColumnar()) {
     return permutation_.empty() && (query_mem_desc_.getQueryDescriptionType() ==
                                         QueryDescriptionType::Projection ||
                                     (query_mem_desc_.getQueryDescriptionType() ==
                                          QueryDescriptionType::GroupByPerfectHash ||
                                      query_mem_desc_.getQueryDescriptionType() ==
                                          QueryDescriptionType::GroupByBaselineHash));
   } else {
     return permutation_.empty() && (query_mem_desc_.getQueryDescriptionType() ==
                                         QueryDescriptionType::GroupByPerfectHash ||
                                     query_mem_desc_.getQueryDescriptionType() ==
                                         QueryDescriptionType::GroupByBaselineHash);
   }
 }

Here is the caller graph for this function:

bool ResultSet::isEmpty ( ) const

Definition at line 384 of file ResultSet.cpp.

                               {
   if (entryCount() == 0) {
     return true;
   }
   if (!storage_) {
     return true;
   }
 
   std::lock_guard<std::mutex> lock(row_iteration_mutex_);
   moveToBegin();
   while (true) {
     auto crt_row = getNextRowUnlocked(false, false);
     if (!crt_row.empty()) {
       return false;
     }
   }
   moveToBegin();
   return true;
 }

bool ResultSet::isExplain ( ) const

Definition at line 475 of file ResultSet.cpp.

                                 {
   return just_explain_;
 }

bool ResultSet::isGeoColOnGpu ( const size_t col_idx ) const

Definition at line 1431 of file ResultSetIteration.cpp.

References CHECK_LT, device_type_, GPU, IS_GEO, lazy_fetch_info_, separate_varlen_storage_valid_, targets_, and to_string().

                                                         {
   // This should match the logic in makeGeoTargetValue which ultimately calls
   // fetch_data_from_gpu when the geo column is on the device.
   // TODO(croot): somehow find a way to refactor this and makeGeoTargetValue to use a
   // utility function that handles this logic in one place
   CHECK_LT(col_idx, targets_.size());
   if (!IS_GEO(targets_[col_idx].sql_type.get_type())) {
     throw std::runtime_error("Column target at index " + std::to_string(col_idx) +
                              " is not a geo column. It is of type " +
                              targets_[col_idx].sql_type.get_type_name() + ".");
   }
 
   const auto& target_info = targets_[col_idx];
   if (separate_varlen_storage_valid_ && !target_info.is_agg) {
     return false;
   }
 
   if (!lazy_fetch_info_.empty()) {
     CHECK_LT(col_idx, lazy_fetch_info_.size());
     if (lazy_fetch_info_[col_idx].is_lazily_fetched) {
       return false;
     }
   }
 
   return device_type_ == ExecutorDeviceType::GPU;
 }

Here is the call graph for this function:

bool ResultSet::isNull	(	const SQLTypeInfo &	ti,
		const InternalTargetValue &	val,
		const bool	float_argument_input
	)

staticprivate

Definition at line 2190 of file ResultSetIteration.cpp.

References CHECK, SQLTypeInfo::get_notnull(), InternalTargetValue::i1, InternalTargetValue::i2, InternalTargetValue::isInt(), InternalTargetValue::isNull(), InternalTargetValue::isPair(), InternalTargetValue::isStr(), and null_val_bit_pattern().

                                                         {
   if (ti.get_notnull()) {
     return false;
   }
   if (val.isInt()) {
     return val.i1 == null_val_bit_pattern(ti, float_argument_input);
   }
   if (val.isPair()) {
     return !val.i2;
   }
   if (val.isStr()) {
     return !val.i1;
   }
   CHECK(val.isNull());
   return true;
 }

Here is the call graph for this function:

const bool ResultSet::isPermutationBufferEmpty ( ) const

inline

Definition at line 377 of file ResultSet.h.

References permutation_.

377 { return permutation_.empty(); };

ResultSet::permutation_

Permutation permutation_

Definition: ResultSet.h:749

bool ResultSet::isRowAtEmpty ( const size_t index ) const

Definition at line 285 of file ResultSetIteration.cpp.

                                                              {
   if (logical_index >= entryCount()) {
     return true;
   }
   const auto entry_idx =
       permutation_.empty() ? logical_index : permutation_[logical_index];
   const auto storage_lookup_result = findStorage(entry_idx);
   const auto storage = storage_lookup_result.storage_ptr;
   const auto local_entry_idx = storage_lookup_result.fixedup_entry_idx;
   return storage->isEmptyEntry(local_entry_idx);
 }

bool ResultSet::isTruncated ( ) const

Definition at line 471 of file ResultSet.cpp.

                                   {
   return keep_first_ + drop_first_;
 }

bool ResultSet::isValidationOnlyRes ( ) const

Definition at line 483 of file ResultSet.cpp.

                                           {
   return for_validation_only_;
 }

bool ResultSet::isZeroCopyColumnarConversionPossible ( size_t column_idx ) const

Definition at line 1067 of file ResultSet.cpp.

References Projection.

                                                                             {
   return query_mem_desc_.didOutputColumnar() &&
          query_mem_desc_.getQueryDescriptionType() == QueryDescriptionType::Projection &&
          appended_storage_.empty() && storage_ &&
          (lazy_fetch_info_.empty() || !lazy_fetch_info_[column_idx].is_lazily_fetched);
 }

void ResultSet::keepFirstN ( const size_t n )

Definition at line 47 of file ResultSet.cpp.

References CHECK_EQ, and anonymous_namespace{Utm.h}::n.

                                          {
   CHECK_EQ(-1, cached_row_count_);
   keep_first_ = n;
 }

int64_t ResultSet::lazyReadInt	(	const int64_t	ival,
		const size_t	target_logical_idx,
		const StorageLookupResult &	storage_lookup_result
	)		const

private

Definition at line 647 of file ResultSetIteration.cpp.

References CHECK, CHECK_LT, ChunkIter_get_nth(), col_buffers_, ResultSet::StorageLookupResult::fixedup_entry_idx, getColumnFrag(), VarlenDatum::is_null, kENCODING_NONE, result_set::lazy_decode(), lazy_fetch_info_, VarlenDatum::length, VarlenDatum::pointer, row_set_mem_owner_, ResultSet::StorageLookupResult::storage_idx, and targets_.

                                                                                        {
   if (!lazy_fetch_info_.empty()) {
     CHECK_LT(target_logical_idx, lazy_fetch_info_.size());
     const auto& col_lazy_fetch = lazy_fetch_info_[target_logical_idx];
     if (col_lazy_fetch.is_lazily_fetched) {
       CHECK_LT(static_cast<size_t>(storage_lookup_result.storage_idx),
                col_buffers_.size());
       int64_t ival_copy = ival;
       auto& frag_col_buffers =
           getColumnFrag(static_cast<size_t>(storage_lookup_result.storage_idx),
                         target_logical_idx,
                         ival_copy);
       auto& frag_col_buffer = frag_col_buffers[col_lazy_fetch.local_col_id];
       CHECK_LT(target_logical_idx, targets_.size());
       const TargetInfo& target_info = targets_[target_logical_idx];
       CHECK(!target_info.is_agg);
       if (target_info.sql_type.is_string() &&
           target_info.sql_type.get_compression() == kENCODING_NONE) {
         VarlenDatum vd;
         bool is_end{false};
         ChunkIter_get_nth(
             reinterpret_cast<ChunkIter*>(const_cast<int8_t*>(frag_col_buffer)),
             storage_lookup_result.fixedup_entry_idx,
             false,
             &vd,
             &is_end);
         CHECK(!is_end);
         if (vd.is_null) {
           return 0;
         }
         std::string fetched_str(reinterpret_cast<char*>(vd.pointer), vd.length);
         return reinterpret_cast<int64_t>(row_set_mem_owner_->addString(fetched_str));
       }
       return result_set::lazy_decode(col_lazy_fetch, frag_col_buffer, ival_copy);
     }
   }
   return ival;
 }

Here is the call graph for this function:

TargetValue ResultSet::makeGeoTargetValue	(	const int8_t *	geo_target_ptr,
		const size_t	slot_idx,
		const TargetInfo &	target_info,
		const size_t	target_logical_idx,
		const size_t	entry_buff_idx
	)		const

private

Definition at line 1462 of file ResultSetIteration.cpp.

References advance_to_next_columnar_target_buff(), CHECK, CHECK_EQ, CHECK_LT, col_buffers_, device_id_, device_type_, QueryMemoryDescriptor::didOutputColumnar(), findStorage(), geo_return_type_, SQLTypeInfo::get_compression(), SQLTypeInfo::get_type(), SQLTypeInfo::get_type_name(), getColumnFrag(), QueryMemoryDescriptor::getExecutor(), QueryMemoryDescriptor::getPaddedColWidthForRange(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), getStorageIndex(), getVarlenOutputInfo(), GPU, i, TargetInfo::is_agg, SQLTypeInfo::is_geometry(), ColumnLazyFetchInfo::is_lazily_fetched, kENCODING_GEOINT, kLINESTRING, kMULTIPOLYGON, kPOINT, kPOLYGON, lazy_fetch_info_, ColumnLazyFetchInfo::local_col_id, query_mem_desc_, read_int_from_buff(), separate_varlen_storage_valid_, serialized_varlen_buffer_, QueryMemoryDescriptor::slotIsVarlenOutput(), TargetInfo::sql_type, and UNREACHABLE.

Referenced by getTargetValueFromBufferColwise(), and getTargetValueFromBufferRowwise().

                                                                              {
   CHECK(target_info.sql_type.is_geometry());
 
   auto getNextTargetBufferRowWise = [&](const size_t slot_idx, const size_t range) {
     return geo_target_ptr + query_mem_desc_.getPaddedColWidthForRange(slot_idx, range);
   };
 
   auto getNextTargetBufferColWise = [&](const size_t slot_idx, const size_t range) {
     const auto storage_info = findStorage(entry_buff_idx);
     auto crt_geo_col_ptr = geo_target_ptr;
     for (size_t i = slot_idx; i < slot_idx + range; i++) {
       crt_geo_col_ptr = advance_to_next_columnar_target_buff(
           crt_geo_col_ptr, storage_info.storage_ptr->query_mem_desc_, i);
     }
     // adjusting the column pointer to represent a pointer to the geo target value
     return crt_geo_col_ptr +
            storage_info.fixedup_entry_idx *
                storage_info.storage_ptr->query_mem_desc_.getPaddedSlotWidthBytes(
                    slot_idx + range);
   };
 
   auto getNextTargetBuffer = [&](const size_t slot_idx, const size_t range) {
     return query_mem_desc_.didOutputColumnar()
                ? getNextTargetBufferColWise(slot_idx, range)
                : getNextTargetBufferRowWise(slot_idx, range);
   };
 
   auto getCoordsDataPtr = [&](const int8_t* geo_target_ptr) {
     return read_int_from_buff(getNextTargetBuffer(slot_idx, 0),
                               query_mem_desc_.getPaddedSlotWidthBytes(slot_idx));
   };
 
   auto getCoordsLength = [&](const int8_t* geo_target_ptr) {
     return read_int_from_buff(getNextTargetBuffer(slot_idx, 1),
                               query_mem_desc_.getPaddedSlotWidthBytes(slot_idx + 1));
   };
 
   auto getRingSizesPtr = [&](const int8_t* geo_target_ptr) {
     return read_int_from_buff(getNextTargetBuffer(slot_idx, 2),
                               query_mem_desc_.getPaddedSlotWidthBytes(slot_idx + 2));
   };
 
   auto getRingSizesLength = [&](const int8_t* geo_target_ptr) {
     return read_int_from_buff(getNextTargetBuffer(slot_idx, 3),
                               query_mem_desc_.getPaddedSlotWidthBytes(slot_idx + 3));
   };
 
   auto getPolyRingsPtr = [&](const int8_t* geo_target_ptr) {
     return read_int_from_buff(getNextTargetBuffer(slot_idx, 4),
                               query_mem_desc_.getPaddedSlotWidthBytes(slot_idx + 4));
   };
 
   auto getPolyRingsLength = [&](const int8_t* geo_target_ptr) {
     return read_int_from_buff(getNextTargetBuffer(slot_idx, 5),
                               query_mem_desc_.getPaddedSlotWidthBytes(slot_idx + 5));
   };
 
   auto getFragColBuffers = [&]() -> decltype(auto) {
     const auto storage_idx = getStorageIndex(entry_buff_idx);
     CHECK_LT(storage_idx.first, col_buffers_.size());
     auto global_idx = getCoordsDataPtr(geo_target_ptr);
     return getColumnFrag(storage_idx.first, target_logical_idx, global_idx);
   };
 
   const bool is_gpu_fetch = device_type_ == ExecutorDeviceType::GPU;
 
   auto getDataMgr = [&]() {
     auto executor = query_mem_desc_.getExecutor();
     CHECK(executor);
     return executor->getDataMgr();
   };
 
   auto getSeparateVarlenStorage = [&]() -> decltype(auto) {
     const auto storage_idx = getStorageIndex(entry_buff_idx);
     CHECK_LT(storage_idx.first, serialized_varlen_buffer_.size());
     const auto& varlen_buffer = serialized_varlen_buffer_[storage_idx.first];
     return varlen_buffer;
   };
 
   if (separate_varlen_storage_valid_ && getCoordsDataPtr(geo_target_ptr) < 0) {
     CHECK_EQ(-1, getCoordsDataPtr(geo_target_ptr));
     return TargetValue(nullptr);
   }
 
   const ColumnLazyFetchInfo* col_lazy_fetch = nullptr;
   if (!lazy_fetch_info_.empty()) {
     CHECK_LT(target_logical_idx, lazy_fetch_info_.size());
     col_lazy_fetch = &lazy_fetch_info_[target_logical_idx];
   }
 
   switch (target_info.sql_type.get_type()) {
     case kPOINT: {
       if (query_mem_desc_.slotIsVarlenOutput(slot_idx)) {
         auto varlen_output_info = getVarlenOutputInfo(entry_buff_idx);
         CHECK(varlen_output_info);
         auto geo_data_ptr = read_int_from_buff(
             geo_target_ptr, query_mem_desc_.getPaddedSlotWidthBytes(slot_idx));
         auto cpu_data_ptr =
             reinterpret_cast<int64_t>(varlen_output_info->computeCpuOffset(geo_data_ptr));
         return GeoTargetValueBuilder<kPOINT, GeoQueryOutputFetchHandler>::build(
             target_info.sql_type,
             geo_return_type_,
             /*data_mgr=*/nullptr,
             /*is_gpu_fetch=*/false,
             device_id_,
             cpu_data_ptr,
             target_info.sql_type.get_compression() == kENCODING_GEOINT ? 8 : 16);
       } else if (separate_varlen_storage_valid_ && !target_info.is_agg) {
         const auto& varlen_buffer = getSeparateVarlenStorage();
         CHECK_LT(static_cast<size_t>(getCoordsDataPtr(geo_target_ptr)),
                  varlen_buffer.size());
 
         return GeoTargetValueBuilder<kPOINT, GeoQueryOutputFetchHandler>::build(
             target_info.sql_type,
             geo_return_type_,
             nullptr,
             false,
             device_id_,
             reinterpret_cast<int64_t>(
                 varlen_buffer[getCoordsDataPtr(geo_target_ptr)].data()),
             static_cast<int64_t>(varlen_buffer[getCoordsDataPtr(geo_target_ptr)].size()));
       } else if (col_lazy_fetch && col_lazy_fetch->is_lazily_fetched) {
         const auto& frag_col_buffers = getFragColBuffers();
         return GeoTargetValueBuilder<kPOINT, GeoLazyFetchHandler>::build(
             target_info.sql_type,
             geo_return_type_,
             frag_col_buffers[col_lazy_fetch->local_col_id],
             getCoordsDataPtr(geo_target_ptr));
       } else {
         return GeoTargetValueBuilder<kPOINT, GeoQueryOutputFetchHandler>::build(
             target_info.sql_type,
             geo_return_type_,
             is_gpu_fetch ? getDataMgr() : nullptr,
             is_gpu_fetch,
             device_id_,
             getCoordsDataPtr(geo_target_ptr),
             getCoordsLength(geo_target_ptr));
       }
       break;
     }
     case kLINESTRING: {
       if (separate_varlen_storage_valid_ && !target_info.is_agg) {
         const auto& varlen_buffer = getSeparateVarlenStorage();
         CHECK_LT(static_cast<size_t>(getCoordsDataPtr(geo_target_ptr)),
                  varlen_buffer.size());
 
         return GeoTargetValueBuilder<kLINESTRING, GeoQueryOutputFetchHandler>::build(
             target_info.sql_type,
             geo_return_type_,
             nullptr,
             false,
             device_id_,
             reinterpret_cast<int64_t>(
                 varlen_buffer[getCoordsDataPtr(geo_target_ptr)].data()),
             static_cast<int64_t>(varlen_buffer[getCoordsDataPtr(geo_target_ptr)].size()));
       } else if (col_lazy_fetch && col_lazy_fetch->is_lazily_fetched) {
         const auto& frag_col_buffers = getFragColBuffers();
         return GeoTargetValueBuilder<kLINESTRING, GeoLazyFetchHandler>::build(
             target_info.sql_type,
             geo_return_type_,
             frag_col_buffers[col_lazy_fetch->local_col_id],
             getCoordsDataPtr(geo_target_ptr));
       } else {
         return GeoTargetValueBuilder<kLINESTRING, GeoQueryOutputFetchHandler>::build(
             target_info.sql_type,
             geo_return_type_,
             is_gpu_fetch ? getDataMgr() : nullptr,
             is_gpu_fetch,
             device_id_,
             getCoordsDataPtr(geo_target_ptr),
             getCoordsLength(geo_target_ptr));
       }
       break;
     }
     case kPOLYGON: {
       if (separate_varlen_storage_valid_ && !target_info.is_agg) {
         const auto& varlen_buffer = getSeparateVarlenStorage();
         CHECK_LT(static_cast<size_t>(getCoordsDataPtr(geo_target_ptr) + 1),
                  varlen_buffer.size());
 
         return GeoTargetValueBuilder<kPOLYGON, GeoQueryOutputFetchHandler>::build(
             target_info.sql_type,
             geo_return_type_,
             nullptr,
             false,
             device_id_,
             reinterpret_cast<int64_t>(
                 varlen_buffer[getCoordsDataPtr(geo_target_ptr)].data()),
             static_cast<int64_t>(varlen_buffer[getCoordsDataPtr(geo_target_ptr)].size()),
             reinterpret_cast<int64_t>(
                 varlen_buffer[getCoordsDataPtr(geo_target_ptr) + 1].data()),
             static_cast<int64_t>(
                 varlen_buffer[getCoordsDataPtr(geo_target_ptr) + 1].size()));
       } else if (col_lazy_fetch && col_lazy_fetch->is_lazily_fetched) {
         const auto& frag_col_buffers = getFragColBuffers();
 
         return GeoTargetValueBuilder<kPOLYGON, GeoLazyFetchHandler>::build(
             target_info.sql_type,
             geo_return_type_,
             frag_col_buffers[col_lazy_fetch->local_col_id],
             getCoordsDataPtr(geo_target_ptr),
             frag_col_buffers[col_lazy_fetch->local_col_id + 1],
             getCoordsDataPtr(geo_target_ptr));
       } else {
         return GeoTargetValueBuilder<kPOLYGON, GeoQueryOutputFetchHandler>::build(
             target_info.sql_type,
             geo_return_type_,
             is_gpu_fetch ? getDataMgr() : nullptr,
             is_gpu_fetch,
             device_id_,
             getCoordsDataPtr(geo_target_ptr),
             getCoordsLength(geo_target_ptr),
             getRingSizesPtr(geo_target_ptr),
             getRingSizesLength(geo_target_ptr) * 4);
       }
       break;
     }
     case kMULTIPOLYGON: {
       if (separate_varlen_storage_valid_ && !target_info.is_agg) {
         const auto& varlen_buffer = getSeparateVarlenStorage();
         CHECK_LT(static_cast<size_t>(getCoordsDataPtr(geo_target_ptr) + 2),
                  varlen_buffer.size());
 
         return GeoTargetValueBuilder<kMULTIPOLYGON, GeoQueryOutputFetchHandler>::build(
             target_info.sql_type,
             geo_return_type_,
             nullptr,
             false,
             device_id_,
             reinterpret_cast<int64_t>(
                 varlen_buffer[getCoordsDataPtr(geo_target_ptr)].data()),
             static_cast<int64_t>(varlen_buffer[getCoordsDataPtr(geo_target_ptr)].size()),
             reinterpret_cast<int64_t>(
                 varlen_buffer[getCoordsDataPtr(geo_target_ptr) + 1].data()),
             static_cast<int64_t>(
                 varlen_buffer[getCoordsDataPtr(geo_target_ptr) + 1].size()),
             reinterpret_cast<int64_t>(
                 varlen_buffer[getCoordsDataPtr(geo_target_ptr) + 2].data()),
             static_cast<int64_t>(
                 varlen_buffer[getCoordsDataPtr(geo_target_ptr) + 2].size()));
       } else if (col_lazy_fetch && col_lazy_fetch->is_lazily_fetched) {
         const auto& frag_col_buffers = getFragColBuffers();
 
         return GeoTargetValueBuilder<kMULTIPOLYGON, GeoLazyFetchHandler>::build(
             target_info.sql_type,
             geo_return_type_,
             frag_col_buffers[col_lazy_fetch->local_col_id],
             getCoordsDataPtr(geo_target_ptr),
             frag_col_buffers[col_lazy_fetch->local_col_id + 1],
             getCoordsDataPtr(geo_target_ptr),
             frag_col_buffers[col_lazy_fetch->local_col_id + 2],
             getCoordsDataPtr(geo_target_ptr));
       } else {
         return GeoTargetValueBuilder<kMULTIPOLYGON, GeoQueryOutputFetchHandler>::build(
             target_info.sql_type,
             geo_return_type_,
             is_gpu_fetch ? getDataMgr() : nullptr,
             is_gpu_fetch,
             device_id_,
             getCoordsDataPtr(geo_target_ptr),
             getCoordsLength(geo_target_ptr),
             getRingSizesPtr(geo_target_ptr),
             getRingSizesLength(geo_target_ptr) * 4,
             getPolyRingsPtr(geo_target_ptr),
             getPolyRingsLength(geo_target_ptr) * 4);
       }
       break;
     }
     default:
       throw std::runtime_error("Unknown Geometry type encountered: " +
                                target_info.sql_type.get_type_name());
   }
   UNREACHABLE();
   return TargetValue(nullptr);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

TargetValue ResultSet::makeTargetValue	(	const int8_t *	ptr,
		const int8_t	compact_sz,
		const TargetInfo &	target_info,
		const size_t	target_logical_idx,
		const bool	translate_strings,
		const bool	decimal_to_double,
		const size_t	entry_buff_idx
	)		const

private

Definition at line 1743 of file ResultSetIteration.cpp.

References TargetInfo::agg_kind, calculateQuantile(), catalog_, CHECK, CHECK_EQ, CHECK_GE, CHECK_LT, col_buffers_, const, count_distinct_set_size(), decimal_to_int_type(), exp_to_scale(), QueryMemoryDescriptor::forceFourByteFloat(), get_compact_type(), getColumnFrag(), QueryMemoryDescriptor::getCountDistinctDescriptor(), getStorageIndex(), inline_int_null_val(), anonymous_namespace{ResultSetIteration.cpp}::int_resize_cast(), TargetInfo::is_agg, SQLTypeInfo::is_date_in_days(), is_distinct_target(), QueryMemoryDescriptor::isLogicalSizedColumnsAllowed(), kAPPROX_QUANTILE, kAVG, kBIGINT, kENCODING_DICT, kFLOAT, kMAX, kMIN, kSINGLE_VALUE, kSUM, result_set::lazy_decode(), lazy_fetch_info_, NULL_DOUBLE, NULL_INT, query_mem_desc_, read_int_from_buff(), row_set_mem_owner_, and TargetInfo::sql_type.

Referenced by getTargetValueFromBufferColwise(), and getTargetValueFromBufferRowwise().

                                                                           {
   auto actual_compact_sz = compact_sz;
   const auto& type_info = target_info.sql_type;
   if (type_info.get_type() == kFLOAT && !query_mem_desc_.forceFourByteFloat()) {
     if (query_mem_desc_.isLogicalSizedColumnsAllowed()) {
       actual_compact_sz = sizeof(float);
     } else {
       actual_compact_sz = sizeof(double);
     }
     if (target_info.is_agg &&
         (target_info.agg_kind == kAVG || target_info.agg_kind == kSUM ||
          target_info.agg_kind == kMIN || target_info.agg_kind == kMAX ||
          target_info.agg_kind == kSINGLE_VALUE)) {
       // The above listed aggregates use two floats in a single 8-byte slot. Set the
       // padded size to 4 bytes to properly read each value.
       actual_compact_sz = sizeof(float);
     }
   }
   if (get_compact_type(target_info).is_date_in_days()) {
     // Dates encoded in days are converted to 8 byte values on read.
     actual_compact_sz = sizeof(int64_t);
   }
 
   // String dictionary keys are read as 32-bit values regardless of encoding
   if (type_info.is_string() && type_info.get_compression() == kENCODING_DICT &&
       type_info.get_comp_param()) {
     actual_compact_sz = sizeof(int32_t);
   }
 
   auto ival = read_int_from_buff(ptr, actual_compact_sz);
   const auto& chosen_type = get_compact_type(target_info);
   if (!lazy_fetch_info_.empty()) {
     CHECK_LT(target_logical_idx, lazy_fetch_info_.size());
     const auto& col_lazy_fetch = lazy_fetch_info_[target_logical_idx];
     if (col_lazy_fetch.is_lazily_fetched) {
       CHECK_GE(ival, 0);
       const auto storage_idx = getStorageIndex(entry_buff_idx);
       CHECK_LT(storage_idx.first, col_buffers_.size());
       auto& frag_col_buffers = getColumnFrag(storage_idx.first, target_logical_idx, ival);
       CHECK_LT(size_t(col_lazy_fetch.local_col_id), frag_col_buffers.size());
       ival = result_set::lazy_decode(
           col_lazy_fetch, frag_col_buffers[col_lazy_fetch.local_col_id], ival);
       if (chosen_type.is_fp()) {
         const auto dval = *reinterpret_cast<const double*>(may_alias_ptr(&ival));
         if (chosen_type.get_type() == kFLOAT) {
           return ScalarTargetValue(static_cast<float>(dval));
         } else {
           return ScalarTargetValue(dval);
         }
       }
     }
   }
   if (chosen_type.is_fp()) {
     if (target_info.agg_kind == kAPPROX_QUANTILE) {
       return *reinterpret_cast<double const*>(ptr) == NULL_DOUBLE
                  ? NULL_DOUBLE  // sql_validate / just_validate
                  : calculateQuantile(*reinterpret_cast<quantile::TDigest* const*>(ptr));
     }
     switch (actual_compact_sz) {
       case 8: {
         const auto dval = *reinterpret_cast<const double*>(ptr);
         return chosen_type.get_type() == kFLOAT
                    ? ScalarTargetValue(static_cast<const float>(dval))
                    : ScalarTargetValue(dval);
       }
       case 4: {
         CHECK_EQ(kFLOAT, chosen_type.get_type());
         return *reinterpret_cast<const float*>(ptr);
       }
       default:
         CHECK(false);
     }
   }
   if (chosen_type.is_integer() | chosen_type.is_boolean() || chosen_type.is_time() ||
       chosen_type.is_timeinterval()) {
     if (is_distinct_target(target_info)) {
       return TargetValue(count_distinct_set_size(
           ival, query_mem_desc_.getCountDistinctDescriptor(target_logical_idx)));
     }
     // TODO(alex): remove int_resize_cast, make read_int_from_buff return the
     // right type instead
     if (inline_int_null_val(chosen_type) ==
         int_resize_cast(ival, chosen_type.get_logical_size())) {
       return inline_int_null_val(type_info);
     }
     return ival;
   }
   if (chosen_type.is_string() && chosen_type.get_compression() == kENCODING_DICT) {
     if (translate_strings) {
       if (static_cast<int32_t>(ival) ==
           NULL_INT) {  // TODO(alex): this isn't nice, fix it
         return NullableString(nullptr);
       }
       StringDictionaryProxy* sdp{nullptr};
       if (!chosen_type.get_comp_param()) {
         sdp = row_set_mem_owner_->getLiteralStringDictProxy();
       } else {
         sdp = catalog_
                   ? row_set_mem_owner_->getOrAddStringDictProxy(
                         chosen_type.get_comp_param(), /*with_generation=*/false, catalog_)
                   : row_set_mem_owner_->getStringDictProxy(
                         chosen_type.get_comp_param());  // unit tests bypass the catalog
       }
       return NullableString(sdp->getString(ival));
     } else {
       return static_cast<int64_t>(static_cast<int32_t>(ival));
     }
   }
   if (chosen_type.is_decimal()) {
     if (decimal_to_double) {
       if (target_info.is_agg &&
           (target_info.agg_kind == kAVG || target_info.agg_kind == kSUM ||
            target_info.agg_kind == kMIN || target_info.agg_kind == kMAX) &&
           ival == inline_int_null_val(SQLTypeInfo(kBIGINT, false))) {
         return NULL_DOUBLE;
       }
       if (!chosen_type.get_notnull() &&
           ival ==
               inline_int_null_val(SQLTypeInfo(decimal_to_int_type(chosen_type), false))) {
         return NULL_DOUBLE;
       }
       return static_cast<double>(ival) / exp_to_scale(chosen_type.get_scale());
     }
     return ival;
   }
   CHECK(false);
   return TargetValue(int64_t(0));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

TargetValue ResultSet::makeVarlenTargetValue	(	const int8_t *	ptr1,
		const int8_t	compact_sz1,
		const int8_t *	ptr2,
		const int8_t	compact_sz2,
		const TargetInfo &	target_info,
		const size_t	target_logical_idx,
		const bool	translate_strings,
		const size_t	entry_buff_idx
	)		const

private

Definition at line 1306 of file ResultSetIteration.cpp.

References anonymous_namespace{ResultSetIteration.cpp}::build_array_target_value(), catalog_, CHECK, CHECK_EQ, CHECK_GE, CHECK_GT, CHECK_LT, ChunkIter_get_nth(), col_buffers_, device_id_, device_type_, SQLTypeInfo::get_array_context_logical_size(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_elem_type(), SQLTypeInfo::get_type(), getColumnFrag(), QueryMemoryDescriptor::getExecutor(), getStorageIndex(), GPU, TargetInfo::is_agg, SQLTypeInfo::is_array(), VarlenDatum::is_null, SQLTypeInfo::is_string(), kARRAY, kENCODING_NONE, lazy_fetch_info_, VarlenDatum::length, run_benchmark_import::optional, VarlenDatum::pointer, query_mem_desc_, read_int_from_buff(), row_set_mem_owner_, separate_varlen_storage_valid_, serialized_varlen_buffer_, and TargetInfo::sql_type.

Referenced by getTargetValueFromBufferColwise(), and getTargetValueFromBufferRowwise().

                                                                                 {
   auto varlen_ptr = read_int_from_buff(ptr1, compact_sz1);
   if (separate_varlen_storage_valid_ && !target_info.is_agg) {
     if (varlen_ptr < 0) {
       CHECK_EQ(-1, varlen_ptr);
       if (target_info.sql_type.get_type() == kARRAY) {
         return ArrayTargetValue(boost::optional<std::vector<ScalarTargetValue>>{});
       }
       return TargetValue(nullptr);
     }
     const auto storage_idx = getStorageIndex(entry_buff_idx);
     if (target_info.sql_type.is_string()) {
       CHECK(target_info.sql_type.get_compression() == kENCODING_NONE);
       CHECK_LT(storage_idx.first, serialized_varlen_buffer_.size());
       const auto& varlen_buffer_for_storage =
           serialized_varlen_buffer_[storage_idx.first];
       CHECK_LT(static_cast<size_t>(varlen_ptr), varlen_buffer_for_storage.size());
       return varlen_buffer_for_storage[varlen_ptr];
     } else if (target_info.sql_type.get_type() == kARRAY) {
       CHECK_LT(storage_idx.first, serialized_varlen_buffer_.size());
       const auto& varlen_buffer = serialized_varlen_buffer_[storage_idx.first];
       CHECK_LT(static_cast<size_t>(varlen_ptr), varlen_buffer.size());
 
       return build_array_target_value(
           target_info.sql_type,
           reinterpret_cast<const int8_t*>(varlen_buffer[varlen_ptr].data()),
           varlen_buffer[varlen_ptr].size(),
           translate_strings,
           row_set_mem_owner_,
           catalog_);
     } else {
       CHECK(false);
     }
   }
   if (!lazy_fetch_info_.empty()) {
     CHECK_LT(target_logical_idx, lazy_fetch_info_.size());
     const auto& col_lazy_fetch = lazy_fetch_info_[target_logical_idx];
     if (col_lazy_fetch.is_lazily_fetched) {
       const auto storage_idx = getStorageIndex(entry_buff_idx);
       CHECK_LT(storage_idx.first, col_buffers_.size());
       auto& frag_col_buffers =
           getColumnFrag(storage_idx.first, target_logical_idx, varlen_ptr);
       bool is_end{false};
       if (target_info.sql_type.is_string()) {
         VarlenDatum vd;
         ChunkIter_get_nth(reinterpret_cast<ChunkIter*>(const_cast<int8_t*>(
                               frag_col_buffers[col_lazy_fetch.local_col_id])),
                           varlen_ptr,
                           false,
                           &vd,
                           &is_end);
         CHECK(!is_end);
         if (vd.is_null) {
           return TargetValue(nullptr);
         }
         CHECK(vd.pointer);
         CHECK_GT(vd.length, 0u);
         std::string fetched_str(reinterpret_cast<char*>(vd.pointer), vd.length);
         return fetched_str;
       } else {
         CHECK(target_info.sql_type.is_array());
         ArrayDatum ad;
         ChunkIter_get_nth(reinterpret_cast<ChunkIter*>(const_cast<int8_t*>(
                               frag_col_buffers[col_lazy_fetch.local_col_id])),
                           varlen_ptr,
                           &ad,
                           &is_end);
         CHECK(!is_end);
         if (ad.is_null) {
           return ArrayTargetValue(boost::optional<std::vector<ScalarTargetValue>>{});
         }
         CHECK_GE(ad.length, 0u);
         if (ad.length > 0) {
           CHECK(ad.pointer);
         }
         return build_array_target_value(target_info.sql_type,
                                         ad.pointer,
                                         ad.length,
                                         translate_strings,
                                         row_set_mem_owner_,
                                         catalog_);
       }
     }
   }
   if (!varlen_ptr) {
     if (target_info.sql_type.is_array()) {
       return ArrayTargetValue(boost::optional<std::vector<ScalarTargetValue>>{});
     }
     return TargetValue(nullptr);
   }
   auto length = read_int_from_buff(ptr2, compact_sz2);
   if (target_info.sql_type.is_array()) {
     const auto& elem_ti = target_info.sql_type.get_elem_type();
     length *= elem_ti.get_array_context_logical_size();
   }
   std::vector<int8_t> cpu_buffer;
   if (varlen_ptr && device_type_ == ExecutorDeviceType::GPU) {
     cpu_buffer.resize(length);
     const auto executor = query_mem_desc_.getExecutor();
     CHECK(executor);
     auto data_mgr = executor->getDataMgr();
     auto allocator = data_mgr->createGpuAllocator(device_id_);
 
     allocator->copyFromDevice(
         &cpu_buffer[0], reinterpret_cast<int8_t*>(varlen_ptr), length);
     varlen_ptr = reinterpret_cast<int64_t>(&cpu_buffer[0]);
   }
   if (target_info.sql_type.is_array()) {
     return build_array_target_value(target_info.sql_type,
                                     reinterpret_cast<const int8_t*>(varlen_ptr),
                                     length,
                                     translate_strings,
                                     row_set_mem_owner_,
                                     catalog_);
   }
   return std::string(reinterpret_cast<char*>(varlen_ptr), length);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ResultSet::moveToBegin ( ) const

Definition at line 466 of file ResultSet.cpp.

                                   {
   crt_row_buff_idx_ = 0;
   fetched_so_far_ = 0;
 }

size_t ResultSet::parallelRowCount ( ) const

private

Definition at line 364 of file ResultSet.cpp.

References anonymous_namespace{ResultSet.cpp}::get_truncated_row_count(), i, threading_serial::parallel_reduce(), logger::query_id(), and logger::set_thread_local_query_id().

                                          {
   using namespace threading;
   auto execute_parallel_row_count = [this, query_id = logger::query_id()](
                                         const blocked_range<size_t>& r,
                                         size_t row_count) {
     auto qid_scope_guard = logger::set_thread_local_query_id(query_id);
     for (size_t i = r.begin(); i < r.end(); ++i) {
       if (!isRowAtEmpty(i)) {
         ++row_count;
       }
     }
     return row_count;
   };
   const auto row_count = parallel_reduce(blocked_range<size_t>(0, entryCount()),
                                          size_t(0),
                                          execute_parallel_row_count,
                                          std::plus<int>());
   return get_truncated_row_count(row_count, getLimit(), drop_first_);
 }

Here is the call graph for this function:

void ResultSet::parallelTop	(	const std::list< Analyzer::OrderEntry > &	order_entries,
		const size_t	top_n,
		const Executor *	executor
	)

private

Definition at line 601 of file ResultSet.cpp.

References gpu_enabled::copy(), cpu_threads(), DEBUG_TIMER, i, logger::query_id(), threading_std::task_group::run(), logger::set_thread_local_query_id(), and threading_std::task_group::wait().

                                                       {
   auto timer = DEBUG_TIMER(__func__);
   const size_t nthreads = cpu_threads();
 
   // Split permutation_ into nthreads subranges and top-sort in-place.
   permutation_.resize(query_mem_desc_.getEntryCount());
   std::vector<PermutationView> permutation_views(nthreads);
   threading::task_group top_sort_threads;
   for (auto interval : makeIntervals<PermutationIdx>(0, permutation_.size(), nthreads)) {
     top_sort_threads.run([this,
                           &order_entries,
                           &permutation_views,
                           top_n,
                           executor,
                           query_id = logger::query_id(),
                           interval] {
       auto qid_scope_guard = logger::set_thread_local_query_id(query_id);
       PermutationView pv(permutation_.data() + interval.begin, 0, interval.size());
       pv = initPermutationBuffer(pv, interval.begin, interval.end);
       const auto compare = createComparator(order_entries, pv, executor, true);
       permutation_views[interval.index] = topPermutation(pv, top_n, compare);
     });
   }
   top_sort_threads.wait();
 
   // In case you are considering implementing a parallel reduction, note that the
   // ResultSetComparator constructor is O(N) in order to materialize some of the aggregate
   // columns as necessary to perform a comparison. This cost is why reduction is chosen to
   // be serial instead; only one more Comparator is needed below.
 
   // Left-copy disjoint top-sorted subranges into one contiguous range.
   // ++++....+++.....+++++...  ->  ++++++++++++............
   auto end = permutation_.begin() + permutation_views.front().size();
   for (size_t i = 1; i < nthreads; ++i) {
     std::copy(permutation_views[i].begin(), permutation_views[i].end(), end);
     end += permutation_views[i].size();
   }
 
   // Top sort final range.
   PermutationView pv(permutation_.data(), end - permutation_.begin());
   const auto compare = createComparator(order_entries, pv, executor, false);
   pv = topPermutation(pv, top_n, compare);
   permutation_.resize(pv.size());
   permutation_.shrink_to_fit();
 }

Here is the call graph for this function:

void ResultSet::radixSortOnCpu ( const std::list< Analyzer::OrderEntry > & order_entries ) const

private

Definition at line 990 of file ResultSet.cpp.

References apply_permutation_cpu(), CHECK, CHECK_EQ, DEBUG_TIMER, and sort_groups_cpu().

                                                             {
   auto timer = DEBUG_TIMER(__func__);
   CHECK(!query_mem_desc_.hasKeylessHash());
   std::vector<int64_t> tmp_buff(query_mem_desc_.getEntryCount());
   std::vector<int32_t> idx_buff(query_mem_desc_.getEntryCount());
   CHECK_EQ(size_t(1), order_entries.size());
   auto buffer_ptr = storage_->getUnderlyingBuffer();
   for (const auto& order_entry : order_entries) {
     const auto target_idx = order_entry.tle_no - 1;
     const auto sortkey_val_buff = reinterpret_cast<int64_t*>(
         buffer_ptr + query_mem_desc_.getColOffInBytes(target_idx));
     const auto chosen_bytes = query_mem_desc_.getPaddedSlotWidthBytes(target_idx);
     sort_groups_cpu(sortkey_val_buff,
                     &idx_buff[0],
                     query_mem_desc_.getEntryCount(),
                     order_entry.is_desc,
                     chosen_bytes);
     apply_permutation_cpu(reinterpret_cast<int64_t*>(buffer_ptr),
                           &idx_buff[0],
                           query_mem_desc_.getEntryCount(),
                           &tmp_buff[0],
                           sizeof(int64_t));
     for (size_t target_idx = 0; target_idx < query_mem_desc_.getSlotCount();
          ++target_idx) {
       if (static_cast<int>(target_idx) == order_entry.tle_no - 1) {
         continue;
       }
       const auto chosen_bytes = query_mem_desc_.getPaddedSlotWidthBytes(target_idx);
       const auto satellite_val_buff = reinterpret_cast<int64_t*>(
           buffer_ptr + query_mem_desc_.getColOffInBytes(target_idx));
       apply_permutation_cpu(satellite_val_buff,
                             &idx_buff[0],
                             query_mem_desc_.getEntryCount(),
                             &tmp_buff[0],
                             chosen_bytes);
     }
   }
 }

Here is the call graph for this function:

void ResultSet::radixSortOnGpu ( const std::list< Analyzer::OrderEntry > & order_entries ) const

private

Definition at line 951 of file ResultSet.cpp.

References catalog_(), CHECK_GT, copy_group_by_buffers_from_gpu(), create_dev_group_by_buffers(), DEBUG_TIMER, GPU, inplace_sort_gpu(), and KernelPerFragment.

                                                             {
   auto timer = DEBUG_TIMER(__func__);
   auto data_mgr = &catalog_->getDataMgr();
   const int device_id{0};
   auto allocator = data_mgr->createGpuAllocator(device_id);
   CHECK_GT(block_size_, 0);
   CHECK_GT(grid_size_, 0);
   std::vector<int64_t*> group_by_buffers(block_size_);
   group_by_buffers[0] = reinterpret_cast<int64_t*>(storage_->getUnderlyingBuffer());
   auto dev_group_by_buffers =
       create_dev_group_by_buffers(allocator.get(),
                                   group_by_buffers,
                                   query_mem_desc_,
                                   block_size_,
                                   grid_size_,
                                   device_id,
                                   ExecutorDispatchMode::KernelPerFragment,
                                   /*num_input_rows=*/-1,
                                   /*prepend_index_buffer=*/true,
                                   /*always_init_group_by_on_host=*/true,
                                   /*use_bump_allocator=*/false,
                                   /*has_varlen_output=*/false,
                                   /*insitu_allocator*=*/nullptr);
   inplace_sort_gpu(
       order_entries, query_mem_desc_, dev_group_by_buffers, data_mgr, device_id);
   copy_group_by_buffers_from_gpu(
       *allocator,
       group_by_buffers,
       query_mem_desc_.getBufferSizeBytes(ExecutorDeviceType::GPU),
       dev_group_by_buffers.data,
       query_mem_desc_,
       block_size_,
       grid_size_,
       device_id,
       /*use_bump_allocator=*/false,
       /*has_varlen_output=*/false);
 }

Here is the call graph for this function:

size_t ResultSet::rowCount ( const bool force_parallel = false ) const

Definition at line 306 of file ResultSet.cpp.

References CHECK_GE, and Projection.

                                                           {
   if (just_explain_) {
     return 1;
   }
   if (!permutation_.empty()) {
     if (drop_first_ > permutation_.size()) {
       return 0;
     }
     const auto limited_row_count = keep_first_ + drop_first_;
     return limited_row_count ? std::min(limited_row_count, permutation_.size())
                              : permutation_.size();
   }
   if (cached_row_count_ != -1) {
     CHECK_GE(cached_row_count_, 0);
     return cached_row_count_;
   }
   if (!storage_) {
     return 0;
   }
   if (permutation_.empty() &&
       query_mem_desc_.getQueryDescriptionType() == QueryDescriptionType::Projection) {
     return binSearchRowCount();
   }
   if (force_parallel || entryCount() > 20000) {
     return parallelRowCount();
   }
   std::lock_guard<std::mutex> lock(row_iteration_mutex_);
   moveToBegin();
   size_t row_count{0};
   while (true) {
     auto crt_row = getNextRowUnlocked(false, false);
     if (crt_row.empty()) {
       break;
     }
     ++row_count;
   }
   moveToBegin();
   return row_count;
 }

ResultSetRowIterator ResultSet::rowIterator	(	size_t	from_logical_index,
		bool	translate_strings,
		bool	decimal_to_double
	)		const

inline

Definition at line 201 of file ResultSet.h.

Referenced by rowIterator().

                                                                         {
     ResultSetRowIterator rowIterator(this, translate_strings, decimal_to_double);
 
     // move to first logical position
     ++rowIterator;
 
     for (size_t index = 0; index < from_logical_index; index++) {
       ++rowIterator;
     }
 
     return rowIterator;
   }

Here is the caller graph for this function:

ResultSetRowIterator ResultSet::rowIterator	(	bool	translate_strings,
		bool	decimal_to_double
	)		const

inline

Definition at line 216 of file ResultSet.h.

References rowIterator().

                                                                         {
     return rowIterator(0, translate_strings, decimal_to_double);
   }

Here is the call graph for this function:

void ResultSet::serialize ( TSerializedRows & serialized_rows ) const

void ResultSet::serializeCountDistinctColumns ( TSerializedRows & ) const

private

void ResultSet::serializeProjection ( TSerializedRows & serialized_rows ) const

private

void ResultSet::serializeVarlenAggColumn	(	int8_t *	buf,
		std::vector< std::string > &	varlen_bufer
	)		const

private

void ResultSet::setCachedRowCount ( const size_t row_count ) const

Definition at line 346 of file ResultSet.cpp.

References CHECK.

                                                               {
   CHECK(cached_row_count_ == -1 || cached_row_count_ == static_cast<int64_t>(row_count));
   cached_row_count_ = row_count;
 }

void ResultSet::setGeoReturnType ( const GeoReturnType val )

inline

Definition at line 399 of file ResultSet.h.

References geo_return_type_.

399 { geo_return_type_ = val; }

ResultSet::geo_return_type_

GeoReturnType geo_return_type_

Definition: ResultSet.h:783

void ResultSet::setKernelQueueTime ( const int64_t kernel_queue_time )

Definition at line 449 of file ResultSet.cpp.

                                                                   {
   timings_.kernel_queue_time = kernel_queue_time;
 }

void ResultSet::setQueueTime ( const int64_t queue_time )

Definition at line 445 of file ResultSet.cpp.

                                                      {
   timings_.executor_queue_time = queue_time;
 }

void ResultSet::setSeparateVarlenStorageValid ( const bool val )

inline

Definition at line 431 of file ResultSet.h.

References separate_varlen_storage_valid_.

                                                      {
     separate_varlen_storage_valid_ = val;
   }

void ResultSet::setValidationOnlyRes ( )

Definition at line 479 of file ResultSet.cpp.

                                      {
   for_validation_only_ = true;
 }

void ResultSet::sort	(	const std::list< Analyzer::OrderEntry > &	order_entries,
		size_t	top_n,
		const Executor *	executor
	)

Definition at line 503 of file ResultSet.cpp.

References Executor::baseline_threshold, CHECK, CHECK_EQ, DEBUG_TIMER, g_enable_watchdog, g_parallel_top_max, g_parallel_top_min, LOG, VectorView< T >::size(), and logger::WARNING.

                                                {
   auto timer = DEBUG_TIMER(__func__);
 
   if (!storage_) {
     return;
   }
   CHECK_EQ(-1, cached_row_count_);
   CHECK(!targets_.empty());
 #ifdef HAVE_CUDA
   if (canUseFastBaselineSort(order_entries, top_n)) {
     baselineSort(order_entries, top_n, executor);
     return;
   }
 #endif  // HAVE_CUDA
   if (query_mem_desc_.sortOnGpu()) {
     try {
       radixSortOnGpu(order_entries);
     } catch (const OutOfMemory&) {
       LOG(WARNING) << "Out of GPU memory during sort, finish on CPU";
       radixSortOnCpu(order_entries);
     } catch (const std::bad_alloc&) {
       LOG(WARNING) << "Out of GPU memory during sort, finish on CPU";
       radixSortOnCpu(order_entries);
     }
     return;
   }
   // This check isn't strictly required, but allows the index buffer to be 32-bit.
   if (query_mem_desc_.getEntryCount() > std::numeric_limits<uint32_t>::max()) {
     throw RowSortException("Sorting more than 4B elements not supported");
   }
 
   CHECK(permutation_.empty());
 
   if (top_n && g_parallel_top_min < entryCount()) {
     if (g_enable_watchdog && g_parallel_top_max < entryCount()) {
       throw WatchdogException("Sorting the result would be too slow");
     }
     parallelTop(order_entries, top_n, executor);
   } else {
     if (g_enable_watchdog && Executor::baseline_threshold < entryCount()) {
       throw WatchdogException("Sorting the result would be too slow");
     }
     permutation_.resize(query_mem_desc_.getEntryCount());
     // PermutationView is used to share common API with parallelTop().
     PermutationView pv(permutation_.data(), 0, permutation_.size());
     pv = initPermutationBuffer(pv, 0, permutation_.size());
     if (top_n == 0) {
       top_n = pv.size();  // top_n == 0 implies a full sort
     }
     pv = topPermutation(pv, top_n, createComparator(order_entries, pv, executor, false));
     if (pv.size() < permutation_.size()) {
       permutation_.resize(pv.size());
       permutation_.shrink_to_fit();
     }
   }
 }

Here is the call graph for this function:

void ResultSet::syncEstimatorBuffer ( ) const

Definition at line 432 of file ResultSet.cpp.

References CHECK, CHECK_EQ, checked_calloc(), data_mgr_(), and GPU.

                                           {
   CHECK(device_type_ == ExecutorDeviceType::GPU);
   CHECK(!host_estimator_buffer_);
   CHECK_EQ(size_t(0), estimator_->getBufferSize() % sizeof(int64_t));
   host_estimator_buffer_ =
       static_cast<int8_t*>(checked_calloc(estimator_->getBufferSize(), 1));
   CHECK(device_estimator_buffer_);
   auto device_buffer_ptr = device_estimator_buffer_->getMemoryPtr();
   auto allocator = data_mgr_->createGpuAllocator(device_id_);
   allocator->copyFromDevice(
       host_estimator_buffer_, device_buffer_ptr, estimator_->getBufferSize());
 }

Here is the call graph for this function:

PermutationView ResultSet::topPermutation	(	PermutationView	permutation,
		const size_t	n,
		const Comparator &	compare
	)

staticprivate

Definition at line 937 of file ResultSet.cpp.

References VectorView< T >::begin(), DEBUG_TIMER, VectorView< T >::end(), anonymous_namespace{Utm.h}::n, VectorView< T >::resize(), VectorView< T >::size(), and gpu_enabled::sort().

                                                                      {
   auto timer = DEBUG_TIMER(__func__);
   if (n < permutation.size()) {
     std::partial_sort(
         permutation.begin(), permutation.begin() + n, permutation.end(), compare);
     permutation.resize(n);
   } else {
     std::sort(permutation.begin(), permutation.end(), compare);
   }
   return permutation;
 }

Here is the call graph for this function:

std::string ResultSet::toString ( ) const

inline

Definition at line 196 of file ResultSet.h.

References query_mem_desc_, targets_, and typeName().

                              {
     return typeName(this) + "(targets=" + ::toString(targets_) +
            ", query_mem_desc=" + ::toString(query_mem_desc_) + ")";
   }

Here is the call graph for this function:

static std::unique_ptr<ResultSet> ResultSet::unserialize	(	const TSerializedRows &	serialized_rows,
		const Executor *
	)

static

void ResultSet::unserializeCountDistinctColumns ( const TSerializedRows & )

private

void ResultSet::updateStorageEntryCount ( const size_t new_entry_count )

inline

Definition at line 232 of file ResultSet.h.

References CHECK, QueryMemoryDescriptor::getQueryDescriptionType(), Projection, query_mem_desc_, QueryMemoryDescriptor::setEntryCount(), and storage_.

                                                              {
     CHECK(query_mem_desc_.getQueryDescriptionType() == QueryDescriptionType::Projection);
     query_mem_desc_.setEntryCount(new_entry_count);
     CHECK(storage_);
     storage_->updateEntryCount(new_entry_count);
   }

Here is the call graph for this function:

Friends And Related Function Documentation

friend class ColumnarResults

friend

Definition at line 787 of file ResultSet.h.

friend class ResultSetManager

friend

Definition at line 785 of file ResultSet.h.

friend class ResultSetRowIterator

friend

Definition at line 786 of file ResultSet.h.

Member Data Documentation

AppendedStorage ResultSet::appended_storage_

private

Definition at line 743 of file ResultSet.h.

Referenced by copyColumnIntoBuffer().

unsigned ResultSet::block_size_ {0}

private

Definition at line 752 of file ResultSet.h.

std::atomic<int64_t> ResultSet::cached_row_count_

mutableprivate

Definition at line 779 of file ResultSet.h.

const Catalog_Namespace::Catalog* ResultSet::catalog_

private

Definition at line 751 of file ResultSet.h.

Referenced by makeTargetValue(), and makeVarlenTargetValue().

std::vector<std::shared_ptr<std::list<ChunkIter> > > ResultSet::chunk_iters_

private

Definition at line 757 of file ResultSet.h.

Referenced by holdChunkIterators().

std::list<std::shared_ptr<Chunk_NS::Chunk> > ResultSet::chunks_

private

Definition at line 756 of file ResultSet.h.

Referenced by holdChunks().

std::vector<std::vector<std::vector<const int8_t*> > > ResultSet::col_buffers_

private

Definition at line 762 of file ResultSet.h.

Referenced by getColumnFrag(), lazyReadInt(), makeGeoTargetValue(), makeTargetValue(), and makeVarlenTargetValue().

std::vector<std::vector<int64_t> > ResultSet::consistent_frag_sizes_

private

Definition at line 764 of file ResultSet.h.

Referenced by getColumnFrag().

size_t ResultSet::crt_row_buff_idx_

mutableprivate

Definition at line 744 of file ResultSet.h.

Data_Namespace::DataMgr* ResultSet::data_mgr_

private

Definition at line 769 of file ResultSet.h.

Data_Namespace::AbstractBuffer* ResultSet::device_estimator_buffer_ {nullptr}

private

Definition at line 767 of file ResultSet.h.

const int ResultSet::device_id_

private

Definition at line 740 of file ResultSet.h.

Referenced by getVarlenOrderEntry(), makeGeoTargetValue(), and makeVarlenTargetValue().

const ExecutorDeviceType ResultSet::device_type_

private

Definition at line 739 of file ResultSet.h.

Referenced by getVarlenOrderEntry(), isGeoColOnGpu(), makeGeoTargetValue(), and makeVarlenTargetValue().

size_t ResultSet::drop_first_

private

Definition at line 746 of file ResultSet.h.

const std::shared_ptr<const Analyzer::Estimator> ResultSet::estimator_

private

Definition at line 766 of file ResultSet.h.

std::string ResultSet::explanation_

private

Definition at line 776 of file ResultSet.h.

Referenced by getExplanation().

size_t ResultSet::fetched_so_far_

mutableprivate

Definition at line 745 of file ResultSet.h.

bool ResultSet::for_validation_only_

private

Definition at line 778 of file ResultSet.h.

std::vector<std::vector<std::vector<int64_t> > > ResultSet::frag_offsets_

private

Definition at line 763 of file ResultSet.h.

Referenced by getColumnFrag().

GeoReturnType ResultSet::geo_return_type_

mutableprivate

Definition at line 783 of file ResultSet.h.

Referenced by getGeoReturnType(), makeGeoTargetValue(), and setGeoReturnType().

unsigned ResultSet::grid_size_ {0}

private

Definition at line 753 of file ResultSet.h.

int8_t* ResultSet::host_estimator_buffer_ {nullptr}

mutableprivate

Definition at line 768 of file ResultSet.h.

const bool ResultSet::just_explain_

private

Definition at line 777 of file ResultSet.h.

Referenced by getExplanation().

size_t ResultSet::keep_first_

private

Definition at line 747 of file ResultSet.h.

const std::vector<ColumnLazyFetchInfo> ResultSet::lazy_fetch_info_

private

Definition at line 761 of file ResultSet.h.

Referenced by getLazyFetchInfo(), isGeoColOnGpu(), lazyReadInt(), makeGeoTargetValue(), makeTargetValue(), and makeVarlenTargetValue().

std::vector<std::vector<int8_t> > ResultSet::literal_buffers_

private

Definition at line 760 of file ResultSet.h.

Referenced by holdLiterals().

Permutation ResultSet::permutation_

private

Definition at line 749 of file ResultSet.h.

Referenced by entryCount(), and isPermutationBufferEmpty().

QueryMemoryDescriptor ResultSet::query_mem_desc_

private

Definition at line 741 of file ResultSet.h.

Referenced by ResultSetStorage::binSearchRowCount(), copyColumnIntoBuffer(), createComparator(), didOutputColumnar(), entryCount(), getPaddedSlotWidthBytes(), getQueryDescriptionType(), getTargetValueFromBufferColwise(), getTargetValueFromBufferRowwise(), getVarlenOrderEntry(), ResultSetStorage::isEmptyEntry(), ResultSetStorage::isEmptyEntryColumnar(), makeGeoTargetValue(), makeTargetValue(), makeVarlenTargetValue(), toString(), and updateStorageEntryCount().

friend ResultSet::ResultSetBuilder

Definition at line 159 of file ResultSet.h.

std::mutex ResultSet::row_iteration_mutex_

mutableprivate

Definition at line 780 of file ResultSet.h.

std::shared_ptr<RowSetMemoryOwner> ResultSet::row_set_mem_owner_

private

Definition at line 748 of file ResultSet.h.

Referenced by getRowSetMemOwner(), getTargetValueFromBufferRowwise(), getVarlenOrderEntry(), lazyReadInt(), makeTargetValue(), and makeVarlenTargetValue().

bool ResultSet::separate_varlen_storage_valid_

private

Definition at line 775 of file ResultSet.h.

Referenced by getTargetValueFromBufferRowwise(), isGeoColOnGpu(), makeGeoTargetValue(), makeVarlenTargetValue(), and setSeparateVarlenStorageValid().

std::vector<SerializedVarlenBufferStorage> ResultSet::serialized_varlen_buffer_

private

Definition at line 774 of file ResultSet.h.

Referenced by makeGeoTargetValue(), and makeVarlenTargetValue().

std::unique_ptr<ResultSetStorage> ResultSet::storage_

mutableprivate

Definition at line 742 of file ResultSet.h.

Referenced by copyColumnIntoBuffer(), fillOneEntry(), getBufferSizeBytes(), getColumnarBaselineEntryAt(), getColumnarPerfectHashEntryAt(), getRowWiseBaselineEntryAt(), getRowWisePerfectHashEntryAt(), getTargetValueFromBufferRowwise(), and updateStorageEntryCount().

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

private

Definition at line 738 of file ResultSet.h.

Referenced by ResultSetStorage::isEmptyEntryColumnar(), isGeoColOnGpu(), lazyReadInt(), and toString().

QueryExecutionTimings ResultSet::timings_

private

Definition at line 754 of file ResultSet.h.

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

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation