#include <ResultSet.h>

Collaboration diagram for ResultSet:

Classes
struct	ColumnWiseTargetAccessor

struct	QueryExecutionTimings

struct	ResultSetComparator

struct	RowIterationState

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

std::string	summaryToString () 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
	Returns the number of valid entries in the result set (i.e that will be returned from the SQL query or inputted into the next query step) More...

void	invalidateCachedRowCount () const

void	setCachedRowCount (const size_t row_count) const

bool	isEmpty () const
	Returns a boolean signifying whether there are valid entries in the result set. More...

size_t	entryCount () const
	Returns the number of entries the result set is allocated to hold. More...

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

ResultSetPtr	copy ()

void	clearPermutation ()

void	initStatus ()

void	invalidateResultSetChunks ()

const bool	isEstimator () const

void	setCached (bool val)

const bool	isCached () const

void	setExecTime (const long exec_time)

const long	getExecTime () const

void	setQueryPlanHash (const QueryPlanHash query_plan)

const QueryPlanHash	getQueryPlanHash ()

std::unordered_set< size_t >	getInputTableKeys () const

void	setInputTableKeys (std::unordered_set< size_t > &&intput_table_keys)

void	setTargetMetaInfo (const std::vector< TargetMetaInfo > &target_meta_info)

std::vector< TargetMetaInfo >	getTargetMetaInfo ()

std::optional< bool >	canUseSpeculativeTopNSort () const

void	setUseSpeculativeTopNSort (bool value)

const bool	hasValidBuffer () 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

bool	areAnyColumnsLazyFetched () const

size_t	getNumColumnsLazyFetched () const

void	setSeparateVarlenStorageValid (const bool val)

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

const std::pair< std::vector < int32_t >, std::vector < std::string > >	getUniqueStringsForDictEncodedTargetCol (const size_t col_idx) const

StringDictionaryProxy *	getStringDictionaryProxy (int const 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

ChunkStats	getTableFunctionChunkStats (const size_t target_idx) const

void	translateDictEncodedColumns (std::vector< TargetInfo > const &, size_t const start_idx)

void	eachCellInColumn (RowIterationState &, CellCallback const &)

const Executor *	getExecutor () 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	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)

size_t	rowCountImpl (const bool force_parallel) const

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 (CountDistinctSet &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_

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_

bool	cached_

size_t	query_exec_time_

QueryPlanHash	query_plan_

std::unordered_set< size_t >	input_table_keys_

std::vector< TargetMetaInfo >	target_meta_info_

std::optional< bool >	can_use_speculative_top_n_sort

Friends
class	ResultSetManager

class	ResultSetRowIterator

class	ColumnarResults

Detailed Description

Definition at line 159 of file ResultSet.h.

Member Typedef Documentation

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

private

Definition at line 795 of file ResultSet.h.

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

private

Definition at line 935 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 519 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 62 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_(uninitialized_cached_row_count)
     , geo_return_type_(GeoReturnType::WktString)
     , cached_(false)
     , query_exec_time_(0)
     , query_plan_(EMPTY_HASHED_PLAN_DAG_KEY)
     , can_use_speculative_top_n_sort(std::nullopt) {}

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 92 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_(uninitialized_cached_row_count)
     , geo_return_type_(GeoReturnType::WktString)
     , cached_(false)
     , query_exec_time_(0)
     , query_plan_(EMPTY_HASHED_PLAN_DAG_KEY)
     , can_use_speculative_top_n_sort(std::nullopt) {}

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 163 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_(uninitialized_cached_row_count)
     , geo_return_type_(GeoReturnType::WktString)
     , cached_(false)
     , query_exec_time_(0)
     , query_plan_(EMPTY_HASHED_PLAN_DAG_KEY)
     , can_use_speculative_top_n_sort(std::nullopt) {}

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

Definition at line 178 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_(uninitialized_cached_row_count)
     , geo_return_type_(GeoReturnType::WktString)
     , cached_(false)
     , query_exec_time_(0)
     , query_plan_(EMPTY_HASHED_PLAN_DAG_KEY)
     , can_use_speculative_top_n_sort(std::nullopt) {}

ResultSet::~ResultSet ( )

Definition at line 196 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 718 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 299 of file ResultSet.cpp.

References CHECK.

                                       {
   invalidateCachedRowCount();
   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));
   }
 }

bool ResultSet::areAnyColumnsLazyFetched ( ) const

inline

Definition at line 561 of file ResultSet.h.

References lazy_fetch_info_.

                                         {
     auto is_lazy = [](auto const& info) { return info.is_lazily_fetched; };
     return std::any_of(lazy_fetch_info_.begin(), lazy_fetch_info_.end(), is_lazy);
   }

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 616 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 1008 of file ResultSet.cpp.

References CHECK, quantile::detail::TDigest< RealType, IndexType >::mergeBufferFinal(), 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->mergeBufferFinal();
   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

std::optional<bool> ResultSet::canUseSpeculativeTopNSort ( ) const

inline

Definition at line 503 of file ResultSet.h.

References can_use_speculative_top_n_sort.

                                                       {
     return can_use_speculative_top_n_sort;
   }

void ResultSet::clearPermutation ( )

inline

Definition at line 448 of file ResultSet.h.

References permutation_.

Referenced by initStatus().

                           {
     if (!permutation_.empty()) {
       permutation_.clear();
     }
   }

Here is the caller graph for this function:

size_t ResultSet::colCount ( ) const

Definition at line 413 of file ResultSet.cpp.

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

ResultSetPtr ResultSet::copy ( )

Definition at line 329 of file ResultSet.cpp.

References CHECK, gpu_enabled::copy(), and DEBUG_TIMER.

                              {
   auto timer = DEBUG_TIMER(__func__);
   if (!storage_) {
     return nullptr;
   }
 
   auto executor = getExecutor();
   CHECK(executor);
   ResultSetPtr copied_rs = std::make_shared<ResultSet>(targets_,
                                                        device_type_,
                                                        query_mem_desc_,
                                                        row_set_mem_owner_,
                                                        executor->getCatalog(),
                                                        executor->blockSize(),
                                                        executor->gridSize());
 
   auto allocate_and_copy_storage =
       [&](const ResultSetStorage* prev_storage) -> std::unique_ptr<ResultSetStorage> {
     const auto& prev_qmd = prev_storage->query_mem_desc_;
     const auto storage_size = prev_qmd.getBufferSizeBytes(device_type_);
     auto buff = row_set_mem_owner_->allocate(storage_size, /*thread_idx=*/0);
     std::unique_ptr<ResultSetStorage> new_storage;
     new_storage.reset(new ResultSetStorage(
         prev_storage->targets_, prev_qmd, buff, /*buff_is_provided=*/true));
     new_storage->target_init_vals_ = prev_storage->target_init_vals_;
     if (prev_storage->varlen_output_info_) {
       new_storage->varlen_output_info_ = prev_storage->varlen_output_info_;
     }
     memcpy(new_storage->buff_, prev_storage->buff_, storage_size);
     new_storage->query_mem_desc_ = prev_qmd;
     return new_storage;
   };
 
   copied_rs->storage_ = allocate_and_copy_storage(storage_.get());
   if (!appended_storage_.empty()) {
     for (const auto& storage : appended_storage_) {
       copied_rs->appended_storage_.push_back(allocate_and_copy_storage(storage.get()));
     }
   }
   std::copy(chunks_.begin(), chunks_.end(), std::back_inserter(copied_rs->chunks_));
   std::copy(chunk_iters_.begin(),
             chunk_iters_.end(),
             std::back_inserter(copied_rs->chunk_iters_));
   std::copy(col_buffers_.begin(),
             col_buffers_.end(),
             std::back_inserter(copied_rs->col_buffers_));
   std::copy(frag_offsets_.begin(),
             frag_offsets_.end(),
             std::back_inserter(copied_rs->frag_offsets_));
   std::copy(consistent_frag_sizes_.begin(),
             consistent_frag_sizes_.end(),
             std::back_inserter(copied_rs->consistent_frag_sizes_));
   if (separate_varlen_storage_valid_) {
     std::copy(serialized_varlen_buffer_.begin(),
               serialized_varlen_buffer_.end(),
               std::back_inserter(copied_rs->serialized_varlen_buffer_));
   }
   std::copy(literal_buffers_.begin(),
             literal_buffers_.end(),
             std::back_inserter(copied_rs->literal_buffers_));
   std::copy(lazy_fetch_info_.begin(),
             lazy_fetch_info_.end(),
             std::back_inserter(copied_rs->lazy_fetch_info_));
 
   copied_rs->permutation_ = permutation_;
   copied_rs->drop_first_ = drop_first_;
   copied_rs->keep_first_ = keep_first_;
   copied_rs->separate_varlen_storage_valid_ = separate_varlen_storage_valid_;
   copied_rs->query_exec_time_ = query_exec_time_;
   copied_rs->input_table_keys_ = input_table_keys_;
   copied_rs->target_meta_info_ = target_meta_info_;
   copied_rs->geo_return_type_ = geo_return_type_;
   copied_rs->query_plan_ = query_plan_;
   if (can_use_speculative_top_n_sort) {
     copied_rs->can_use_speculative_top_n_sort = can_use_speculative_top_n_sort;
   }
 
   return copied_rs;
 }

Here is the call graph for this function:

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 copies its content into a contiguous output_buffer

Definition at line 1123 of file ResultSetIteration.cpp.

References appended_storage_, CHECK, CHECK_LT, QueryMemoryDescriptor::getPaddedSlotWidthBytes(), QueryMemoryDescriptor::getSlotCount(), 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 ( CountDistinctSet & 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 836 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 668 of file ResultSet.cpp.

                                           {
   return (!storage_ && !estimator_ && !just_explain_) || cached_row_count_ == 0;
 }

bool ResultSet::didOutputColumnar ( ) const

inline

Definition at line 537 of file ResultSet.h.

References QueryMemoryDescriptor::didOutputColumnar(), and query_mem_desc_.

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

ResultSet::query_mem_desc_

QueryMemoryDescriptor query_mem_desc_

Definition: ResultSet.h:904

QueryMemoryDescriptor::didOutputColumnar

bool didOutputColumnar() const

Definition: QueryMemoryDescriptor.h:268

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 57 of file ResultSet.cpp.

References anonymous_namespace{Utm.h}::n.

                                          {
   invalidateCachedRowCount();
   drop_first_ = n;
 }

void ResultSet::eachCellInColumn	(	RowIterationState &	state,
		CellCallback const &	func
	)

Definition at line 485 of file ResultSet.cpp.

References advance_slot(), advance_to_next_columnar_target_buff(), ResultSet::RowIterationState::agg_idx_, align_to_int64(), ResultSet::RowIterationState::buf_ptr_, CHECK, CHECK_GE, CHECK_LT, ResultSet::RowIterationState::compact_sz1_, ResultSet::RowIterationState::cur_target_idx_, QueryMemoryDescriptor::didOutputColumnar(), get_cols_ptr(), get_key_bytes_rowwise(), QueryMemoryDescriptor::getPaddedSlotWidthBytes(), ResultSet::RowIterationState::prev_target_idx_, read_int_from_buff(), and row_ptr_rowwise().

                                                                                    {
   size_t const target_idx = state.cur_target_idx_;
   QueryMemoryDescriptor& storage_qmd = storage_->query_mem_desc_;
   CHECK_LT(target_idx, lazy_fetch_info_.size());
   auto& col_lazy_fetch = lazy_fetch_info_[target_idx];
   CHECK(col_lazy_fetch.is_lazily_fetched);
   int const target_size = storage_->targets_[target_idx].sql_type.get_size();
   CHECK_LT(0, target_size) << storage_->targets_[target_idx].toString();
   size_t const nrows = storage_->binSearchRowCount();
   if (storage_qmd.didOutputColumnar()) {
     // Logic based on ResultSet::ColumnWiseTargetAccessor::initializeOffsetsForStorage()
     if (state.buf_ptr_ == nullptr) {
       state.buf_ptr_ = get_cols_ptr(storage_->buff_, storage_qmd);
       state.compact_sz1_ = storage_qmd.getPaddedSlotWidthBytes(state.agg_idx_)
                                ? storage_qmd.getPaddedSlotWidthBytes(state.agg_idx_)
                                : query_mem_desc_.getEffectiveKeyWidth();
     }
     for (size_t j = state.prev_target_idx_; j < state.cur_target_idx_; ++j) {
       size_t const next_target_idx = j + 1;  // Set state to reflect next target_idx j+1
       state.buf_ptr_ = advance_to_next_columnar_target_buff(
           state.buf_ptr_, storage_qmd, state.agg_idx_);
       auto const& next_agg_info = storage_->targets_[next_target_idx];
       state.agg_idx_ =
           advance_slot(state.agg_idx_, next_agg_info, separate_varlen_storage_valid_);
       state.compact_sz1_ = storage_qmd.getPaddedSlotWidthBytes(state.agg_idx_)
                                ? storage_qmd.getPaddedSlotWidthBytes(state.agg_idx_)
                                : query_mem_desc_.getEffectiveKeyWidth();
     }
     for (size_t i = 0; i < nrows; ++i) {
       int8_t const* const pos_ptr = state.buf_ptr_ + i * state.compact_sz1_;
       int64_t pos = read_int_from_buff(pos_ptr, target_size);
       CHECK_GE(pos, 0);
       auto& frag_col_buffers = getColumnFrag(0, target_idx, pos);
       CHECK_LT(size_t(col_lazy_fetch.local_col_id), frag_col_buffers.size());
       int8_t const* const col_frag = frag_col_buffers[col_lazy_fetch.local_col_id];
       func(col_frag + pos * target_size);
     }
   } else {
     size_t const key_bytes_with_padding =
         align_to_int64(get_key_bytes_rowwise(storage_qmd));
     for (size_t i = 0; i < nrows; ++i) {
       int8_t const* const keys_ptr = row_ptr_rowwise(storage_->buff_, storage_qmd, i);
       int8_t const* const rowwise_target_ptr = keys_ptr + key_bytes_with_padding;
       int64_t pos = *reinterpret_cast<int64_t const*>(rowwise_target_ptr);
       auto& frag_col_buffers = getColumnFrag(0, target_idx, pos);
       CHECK_LT(size_t(col_lazy_fetch.local_col_id), frag_col_buffers.size());
       int8_t const* const col_frag = frag_col_buffers[col_lazy_fetch.local_col_id];
       func(col_frag + pos * target_size);
     }
   }
 }

Here is the call graph for this function:

size_t ResultSet::entryCount ( ) const

Returns the number of entries the result set is allocated to hold.

Note that this can be greater than or equal to the actual number of valid rows in the result set, whether due to a SQL LIMIT/OFFSET applied or because the result set representation is inherently sparse (i.e. baseline hash group by)

For getting the number of valid rows in the result set (inclusive of any applied LIMIT and/or OFFSET), use ResultSet::rowCount(). Or to just test if there are any valid rows, use ResultSet::entryCount(), as a return value from entryCount() greater than 0 does not neccesarily mean the result set is empty.

Definition at line 752 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 410 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 939 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 756 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 756 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 417 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 1295 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 1388 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 1241 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 1088 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 291 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 686 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 752 of file ResultSet.cpp.

                                  {
   return device_id_;
 }

ExecutorDeviceType ResultSet::getDeviceType ( ) const

Definition at line 250 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 1165 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;
   }
 }

const long ResultSet::getExecTime ( ) const

inline

Definition at line 483 of file ResultSet.h.

References query_exec_time_.

483 { return query_exec_time_; }

ResultSet::query_exec_time_

size_t query_exec_time_

Definition: ResultSet.h:951

const Executor* ResultSet::getExecutor ( ) const

inline

Definition at line 605 of file ResultSet.h.

References QueryMemoryDescriptor::getExecutor(), and query_mem_desc_.

605 { return query_mem_desc_.getExecutor(); }

ResultSet::query_mem_desc_

QueryMemoryDescriptor query_mem_desc_

Definition: ResultSet.h:904

QueryMemoryDescriptor::getExecutor

const Executor * getExecutor() const

Definition: QueryMemoryDescriptor.h:168

Here is the call graph for this function:

std::string ResultSet::getExplanation ( ) const

inline

Definition at line 395 of file ResultSet.h.

References explanation_, and just_explain_.

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

GeoReturnType ResultSet::getGeoReturnType ( ) const

inline

Definition at line 528 of file ResultSet.h.

References geo_return_type_.

528 { return geo_return_type_; }

ResultSet::geo_return_type_

GeoReturnType geo_return_type_

Definition: ResultSet.h:946

int ResultSet::getGpuCount ( ) const

private

int8_t * ResultSet::getHostEstimatorBuffer ( ) const

Definition at line 692 of file ResultSet.cpp.

                                                 {
   return host_estimator_buffer_;
 }

std::unordered_set<size_t> ResultSet::getInputTableKeys ( ) const

inline

Definition at line 489 of file ResultSet.h.

References input_table_keys_.

489 { return input_table_keys_; }

ResultSet::input_table_keys_

std::unordered_set< size_t > input_table_keys_

Definition: ResultSet.h:953

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

inline

Definition at line 557 of file ResultSet.h.

References lazy_fetch_info_.

                                                                  {
     return lazy_fetch_info_;
   }

size_t ResultSet::getLimit ( ) const

Definition at line 1302 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 298 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 320 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 307 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);
 }

size_t ResultSet::getNumColumnsLazyFetched ( ) const

inline

Definition at line 566 of file ResultSet.h.

References lazy_fetch_info_.

                                           {
     auto is_lazy = [](auto const& info) { return info.is_lazily_fetched; };
     return std::count_if(lazy_fetch_info_.begin(), lazy_fetch_info_.end(), is_lazy);
   }

OneIntegerColumnRow ResultSet::getOneColRow ( const size_t index ) const

Definition at line 236 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 546 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 862 of file ResultSet.cpp.

                                                          {
   return permutation_;
 }

QueryDescriptionType ResultSet::getQueryDescriptionType ( ) const

inline

Definition at line 542 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 672 of file ResultSet.cpp.

References CHECK.

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

const QueryPlanHash ResultSet::getQueryPlanHash ( )

inline

Definition at line 487 of file ResultSet.h.

References query_plan_.

487 { return query_plan_; }

ResultSet::query_plan_

QueryPlanHash query_plan_

Definition: ResultSet.h:952

int64_t ResultSet::getQueueTime ( ) const

Definition at line 722 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 727 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 275 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 431 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 1273 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 1256 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 1394 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 1437 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 409 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 914 of file ResultSet.cpp.

References CHECK_NE, 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:

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

Definition at line 1306 of file ResultSet.cpp.

References catalog_(), and CHECK.

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

Here is the call graph for this function:

StringDictionaryProxy * ResultSet::getStringDictionaryProxy ( int const dict_id ) const

Definition at line 426 of file ResultSet.cpp.

References catalog_().

                                                                                   {
   constexpr bool with_generation = true;
   return catalog_ ? row_set_mem_owner_->getOrAddStringDictProxy(
                         dict_id, with_generation, catalog_)
                   : row_set_mem_owner_->getStringDictProxy(dict_id);
 }

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 1418 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:

ChunkStats ResultSet::getTableFunctionChunkStats ( const size_t target_idx ) const

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

Definition at line 677 of file ResultSet.cpp.

                                                              {
   return targets_;
 }

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

Definition at line 681 of file ResultSet.cpp.

References CHECK.

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

std::vector<TargetMetaInfo> ResultSet::getTargetMetaInfo ( )

inline

Definition at line 501 of file ResultSet.h.

References target_meta_info_.

501 { return target_meta_info_; }

ResultSet::target_meta_info_

std::vector< TargetMetaInfo > target_meta_info_

Definition: ResultSet.h:954

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 1887 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 1960 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:

const std::pair< std::vector< int32_t >, std::vector< std::string > > ResultSet::getUniqueStringsForDictEncodedTargetCol ( const size_t col_idx ) const

Definition at line 1315 of file ResultSet.cpp.

References catalog_(), CHECK, and inline_fixed_encoding_null_val().

                                                                              {
   const auto col_type_info = getColType(col_idx);
   CHECK(col_type_info.is_dict_encoded_string());
   std::unordered_set<int32_t> unique_string_ids_set;
   const size_t num_entries = entryCount();
   std::vector<bool> targets_to_skip(colCount(), true);
   targets_to_skip[col_idx] = false;
   const auto null_val = inline_fixed_encoding_null_val(col_type_info);
 
   for (size_t row_idx = 0; row_idx < num_entries; ++row_idx) {
     const auto result_row = getRowAtNoTranslations(row_idx, targets_to_skip);
     if (!result_row.empty()) {
       const auto scalar_col_val = boost::get<ScalarTargetValue>(result_row[col_idx]);
       const int32_t string_id = static_cast<int32_t>(boost::get<int64_t>(scalar_col_val));
       if (string_id != null_val) {
         unique_string_ids_set.emplace(string_id);
       }
     }
   }
 
   const size_t num_unique_strings = unique_string_ids_set.size();
   std::vector<int32_t> unique_string_ids(num_unique_strings);
   size_t string_idx{0};
   for (const auto unique_string_id : unique_string_ids_set) {
     unique_string_ids[string_idx++] = unique_string_id;
   }
 
   const int32_t dict_id = col_type_info.get_comp_param();
   const auto sdp = row_set_mem_owner_->getOrAddStringDictProxy(
       dict_id, /*with_generation=*/true, catalog_);
   CHECK(sdp);
 
   return std::make_pair(unique_string_ids, sdp->getStrings(unique_string_ids));
 }

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 627 of file ResultSetIteration.cpp.

References CHECK, CPU, device_id_, device_type_, QueryMemoryDescriptor::getExecutor(), getQueryEngineCudaStreamForDevice(), 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 = std::make_unique<CudaAllocator>(
         data_mgr, device_id_, getQueryEngineCudaStreamForDevice(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 1113 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:

const bool ResultSet::hasValidBuffer ( ) const

inline

Definition at line 509 of file ResultSet.h.

References storage_.

                                     {
     if (storage_) {
       return true;
     }
     return false;
   }

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

inline

Definition at line 424 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 421 of file ResultSet.h.

References chunks_.

                                                                        {
     chunks_ = chunks;
   }

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

inline

Definition at line 427 of file ResultSet.h.

References literal_buffers_.

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

void ResultSet::initializeStorage ( ) const

Definition at line 1045 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 846 of file ResultSet.cpp.

References CHECK, DEBUG_TIMER, 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:

void ResultSet::initStatus ( )

inline

Definition at line 454 of file ResultSet.h.

References clearPermutation(), crt_row_buff_idx_, drop_first_, fetched_so_far_, invalidateCachedRowCount(), keep_first_, setGeoReturnType(), and WktString.

                     {
     // todo(yoonmin): what else we additionally need to consider
     // to make completely clear status of the resultset for reuse?
     crt_row_buff_idx_ = 0;
     fetched_so_far_ = 0;
     clearPermutation();
     setGeoReturnType(ResultSet::GeoReturnType::WktString);
     invalidateCachedRowCount();
     drop_first_ = 0;
     keep_first_ = 0;
   }

Here is the call graph for this function:

void ResultSet::invalidateCachedRowCount ( ) const

Definition at line 605 of file ResultSet.cpp.

References uninitialized_cached_row_count.

Referenced by initStatus().

                                                {
   cached_row_count_ = uninitialized_cached_row_count;
 }

Here is the caller graph for this function:

void ResultSet::invalidateResultSetChunks ( )

inline

Definition at line 466 of file ResultSet.h.

References chunk_iters_, and chunks_.

                                    {
     if (!chunks_.empty()) {
       chunks_.clear();
     }
     if (!chunk_iters_.empty()) {
       chunk_iters_.clear();
     }
   };

const bool ResultSet::isCached ( ) const

inline

Definition at line 479 of file ResultSet.h.

References cached_.

479 { return cached_; }

ResultSet::cached_

bool cached_

Definition: ResultSet.h:949

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 1357 of file ResultSet.cpp.

References CHECK, g_enable_direct_columnarization, GroupByBaselineHash, GroupByPerfectHash, Projection, and TableFunction.

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::TableFunction ||
                                     query_mem_desc_.getQueryDescriptionType() ==
                                         QueryDescriptionType::GroupByPerfectHash ||
                                     query_mem_desc_.getQueryDescriptionType() ==
                                         QueryDescriptionType::GroupByBaselineHash);
   } else {
     CHECK(!(query_mem_desc_.getQueryDescriptionType() ==
             QueryDescriptionType::TableFunction));
     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

Returns a boolean signifying whether there are valid entries in the result set.

Note a result set can be logically empty even if the value returned by ResultSet::entryCount() is > 0, whether due to a SQL LIMIT/OFFSET applied or because the result set representation is inherently sparse (i.e. baseline hash group by).

Internally this function is just implemented as ResultSet::rowCount() == 0, which caches it's value so the row count will only be computed once per finalized result set.

Definition at line 649 of file ResultSet.cpp.

                               {
   // To simplify this function and de-dup logic with ResultSet::rowCount()
   // (mismatches between the two were causing bugs), we modified this function
   // to simply fetch rowCount(). The potential downside of this approach is that
   // in some cases more work will need to be done, as we can't just stop at the first row.
   // Mitigating that for most cases is the following:
   // 1) rowCount() is cached, so the logic for actually computing row counts will run only
   // once
   //    per result set.
   // 2) If the cache is empty (cached_row_count_ == -1), rowCount() will use parallel
   //    methods if deemed appropriate, which in many cases could be faster for a sparse
   //    large result set that single-threaded iteration from the beginning
   // 3) Often where isEmpty() is needed, rowCount() is also needed. Since the first call
   // to rowCount()
   //    will be cached, there is no extra overhead in these cases
 
   return rowCount() == size_t(0);
 }

const bool ResultSet::isEstimator ( ) const

inline

Definition at line 475 of file ResultSet.h.

References estimator_.

475 { return !estimator_; }

ResultSet::estimator_

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

Definition: ResultSet.h:929

bool ResultSet::isExplain ( ) const

Definition at line 740 of file ResultSet.cpp.

                                 {
   return just_explain_;
 }

bool ResultSet::isGeoColOnGpu ( const size_t col_idx ) const

Definition at line 1436 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 2203 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 436 of file ResultSet.h.

References permutation_.

436 { return permutation_.empty(); };

ResultSet::permutation_

Permutation permutation_

Definition: ResultSet.h:912

bool ResultSet::isRowAtEmpty ( const size_t index ) const

Definition at line 286 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 736 of file ResultSet.cpp.

                                   {
   return keep_first_ + drop_first_;
 }

bool ResultSet::isValidationOnlyRes ( ) const

Definition at line 748 of file ResultSet.cpp.

                                           {
   return for_validation_only_;
 }

bool ResultSet::isZeroCopyColumnarConversionPossible ( size_t column_idx ) const

Definition at line 1379 of file ResultSet.cpp.

References Projection, and TableFunction.

                                                                             {
   return query_mem_desc_.didOutputColumnar() &&
          (query_mem_desc_.getQueryDescriptionType() == QueryDescriptionType::Projection ||
           query_mem_desc_.getQueryDescriptionType() ==
               QueryDescriptionType::TableFunction) &&
          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 52 of file ResultSet.cpp.

References anonymous_namespace{Utm.h}::n.

                                          {
   invalidateCachedRowCount();
   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 649 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 1467 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, 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 1748 of file ResultSetIteration.cpp.

References TargetInfo::agg_kind, calculateQuantile(), catalog_, CHECK, CHECK_EQ, CHECK_GE, CHECK_LT, col_buffers_, 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 1310 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(), getQueryEngineCudaStreamForDevice(), 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 = std::make_unique<CudaAllocator>(
         data_mgr, device_id_, getQueryEngineCudaStreamForDevice(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 731 of file ResultSet.cpp.

                                   {
   crt_row_buff_idx_ = 0;
   fetched_so_far_ = 0;
 }

size_t ResultSet::parallelRowCount ( ) const

private

Definition at line 629 of file ResultSet.cpp.

References anonymous_namespace{ResultSet.cpp}::get_truncated_row_count(), 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 866 of file ResultSet.cpp.

References gpu_enabled::copy(), cpu_threads(), DEBUG_TIMER, 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 1262 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 1222 of file ResultSet.cpp.

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

                                                             {
   auto timer = DEBUG_TIMER(__func__);
   auto data_mgr = &catalog_->getDataMgr();
   const int device_id{0};
   auto allocator = std::make_unique<CudaAllocator>(
       data_mgr, device_id, getQueryEngineCudaStreamForDevice(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

Returns the number of valid entries in the result set (i.e that will be returned from the SQL query or inputted into the next query step)

Note that this can be less than or equal to the value returned by ResultSet::getEntries(), whether due to a SQL LIMIT/OFFSET applied or because the result set representation is inherently sparse (i.e. baseline hash group by).

Internally this function references/sets a cached value (cached_row_count_) so that the cost of computing the result is only paid once per result set.

If the actual row count is not cached and needs to be computed, in some cases that can be O(1) (i.e. if limits and offsets are present, or for the output of a table function). For projections, we use a binary search, so it is O(log n), otherwise it is O(n) (with n being ResultSet::entryCount()), which will be run in parallel if the entry count >= the default of 20000 or if force_parallel is set to true

Note that we currently do not invalidate the cache if the result set is changed (i.e appended to), so this function should only be called after the result set is finalized.

Parameters

force_parallel Forces the row count to be computed in parallel if the row count cannot be otherwise be computed from metadata or via a binary search (otherwise parallel search is automatically used for result sets with entryCount() >= 20000)

Definition at line 593 of file ResultSet.cpp.

References CHECK_GE, and uninitialized_cached_row_count.

                                                           {
   // cached_row_count_ is atomic, so fetch it into a local variable first
   // to avoid repeat fetches
   const int64_t cached_row_count = cached_row_count_;
   if (cached_row_count != uninitialized_cached_row_count) {
     CHECK_GE(cached_row_count, 0);
     return cached_row_count;
   }
   setCachedRowCount(rowCountImpl(force_parallel));
   return cached_row_count_;
 }

size_t ResultSet::rowCountImpl ( const bool force_parallel ) const

private

Definition at line 555 of file ResultSet.cpp.

References CHECK, anonymous_namespace{ResultSet.cpp}::get_truncated_row_count(), Projection, and TableFunction.

                                                               {
   if (just_explain_) {
     return 1;
   }
   if (query_mem_desc_.getQueryDescriptionType() == QueryDescriptionType::TableFunction) {
     return entryCount();
   }
   if (!permutation_.empty()) {
     // keep_first_ corresponds to SQL LIMIT
     // drop_first_ corresponds to SQL OFFSET
     return get_truncated_row_count(permutation_.size(), keep_first_, drop_first_);
   }
   if (!storage_) {
     return 0;
   }
   CHECK(permutation_.empty());
   if (query_mem_desc_.getQueryDescriptionType() == QueryDescriptionType::Projection) {
     return binSearchRowCount();
   }
 
   constexpr size_t auto_parallel_row_count_threshold{20000UL};
   if (force_parallel || entryCount() >= auto_parallel_row_count_threshold) {
     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;
 }

Here is the call graph for this function:

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

inline

Definition at line 205 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 220 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::setCached ( bool val )

inline

Definition at line 477 of file ResultSet.h.

References cached_.

477 { cached_ = val; }

ResultSet::cached_

bool cached_

Definition: ResultSet.h:949

void ResultSet::setCachedRowCount ( const size_t row_count ) const

Definition at line 609 of file ResultSet.cpp.

References CHECK, and uninitialized_cached_row_count.

                                                               {
   const int64_t signed_row_count = static_cast<int64_t>(row_count);
   const int64_t old_cached_row_count = cached_row_count_.exchange(signed_row_count);
   CHECK(old_cached_row_count == uninitialized_cached_row_count ||
         old_cached_row_count == signed_row_count);
 }

void ResultSet::setExecTime ( const long exec_time )

inline

Definition at line 481 of file ResultSet.h.

References query_exec_time_.

481 { query_exec_time_ = exec_time; }

ResultSet::query_exec_time_

size_t query_exec_time_

Definition: ResultSet.h:951

void ResultSet::setGeoReturnType ( const GeoReturnType val )

inline

Definition at line 529 of file ResultSet.h.

References geo_return_type_.

Referenced by initStatus().

529 { geo_return_type_ = val; }

ResultSet::geo_return_type_

GeoReturnType geo_return_type_

Definition: ResultSet.h:946

Here is the caller graph for this function:

void ResultSet::setInputTableKeys ( std::unordered_set< size_t > && intput_table_keys )

inline

Definition at line 491 of file ResultSet.h.

References input_table_keys_.

                                                                        {
     input_table_keys_ = std::move(intput_table_keys);
   }

void ResultSet::setKernelQueueTime ( const int64_t kernel_queue_time )

Definition at line 714 of file ResultSet.cpp.

                                                                   {
   timings_.kernel_queue_time = kernel_queue_time;
 }

void ResultSet::setQueryPlanHash ( const QueryPlanHash query_plan )

inline

Definition at line 485 of file ResultSet.h.

References query_plan_.

485 { query_plan_ = query_plan; }

ResultSet::query_plan_

QueryPlanHash query_plan_

Definition: ResultSet.h:952

void ResultSet::setQueueTime ( const int64_t queue_time )

Definition at line 710 of file ResultSet.cpp.

                                                      {
   timings_.executor_queue_time = queue_time;
 }

void ResultSet::setSeparateVarlenStorageValid ( const bool val )

inline

Definition at line 571 of file ResultSet.h.

References separate_varlen_storage_valid_.

                                                      {
     separate_varlen_storage_valid_ = val;
   }

void ResultSet::setTargetMetaInfo ( const std::vector< TargetMetaInfo > & target_meta_info )

inline

Definition at line 495 of file ResultSet.h.

References gpu_enabled::copy(), and target_meta_info_.

                                                                             {
     std::copy(target_meta_info.begin(),
               target_meta_info.end(),
               std::back_inserter(target_meta_info_));
   }

Here is the call graph for this function:

void ResultSet::setUseSpeculativeTopNSort ( bool value )

inline

Definition at line 507 of file ResultSet.h.

References can_use_speculative_top_n_sort.

507 { can_use_speculative_top_n_sort = value; }

ResultSet::can_use_speculative_top_n_sort

std::optional< bool > can_use_speculative_top_n_sort

Definition: ResultSet.h:959

void ResultSet::setValidationOnlyRes ( )

Definition at line 744 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 768 of file ResultSet.cpp.

References Executor::baseline_threshold, CHECK, 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;
   }
   invalidateCachedRowCount();
   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:

std::string ResultSet::summaryToString ( ) const

Definition at line 218 of file ResultSet.cpp.

                                            {
   std::ostringstream oss;
   oss << "Result Set Info" << std::endl;
   oss << "\tLayout: " << query_mem_desc_.queryDescTypeToString() << std::endl;
   oss << "\tColumns: " << colCount() << std::endl;
   oss << "\tRows: " << rowCount() << std::endl;
   oss << "\tEntry count: " << entryCount() << std::endl;
   const std::string is_empty = isEmpty() ? "True" : "False";
   oss << "\tIs empty: " << is_empty << std::endl;
   const std::string did_output_columnar = didOutputColumnar() ? "True" : "False;";
   oss << "\tColumnar: " << did_output_columnar << std::endl;
   oss << "\tLazy-fetched columns: " << getNumColumnsLazyFetched() << std::endl;
   const std::string is_direct_columnar_conversion_possible =
       isDirectColumnarConversionPossible() ? "True" : "False";
   oss << "\tDirect columnar conversion possible: "
       << is_direct_columnar_conversion_possible << std::endl;
 
   size_t num_columns_zero_copy_columnarizable{0};
   for (size_t target_idx = 0; target_idx < targets_.size(); target_idx++) {
     if (isZeroCopyColumnarConversionPossible(target_idx)) {
       num_columns_zero_copy_columnarizable++;
     }
   }
   oss << "\tZero-copy columnar conversion columns: "
       << num_columns_zero_copy_columnarizable << std::endl;
 
   oss << "\tPermutation size: " << permutation_.size() << std::endl;
   oss << "\tLimit: " << keep_first_ << std::endl;
   oss << "\tOffset: " << drop_first_ << std::endl;
   return oss.str();
 }

void ResultSet::syncEstimatorBuffer ( ) const

Definition at line 696 of file ResultSet.cpp.

References CHECK, CHECK_EQ, checked_calloc(), data_mgr_(), getQueryEngineCudaStreamForDevice(), 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 = std::make_unique<CudaAllocator>(
       data_mgr_, device_id_, getQueryEngineCudaStreamForDevice(device_id_));
   allocator->copyFromDevice(
       host_estimator_buffer_, device_buffer_ptr, estimator_->getBufferSize());
 }

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