#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 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 int thread_idx, const QueryMemoryDescriptor &query_mem_desc, const std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner, 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 ExecutorDeviceType device_type, 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

int	getThreadIdx () const

std::string	getString (SQLTypeInfo const &, int64_t const ival) const

ScalarTargetValue	convertToScalarTargetValue (SQLTypeInfo const &, bool const translate_strings, int64_t const val) const

bool	isLessThan (SQLTypeInfo const &, int64_t const lhs, int64_t const rhs) 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

unsigned	getBlockSize () const

unsigned	getGridSize () 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

const size_t	getColumnarBufferSize (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 shared::StringDictKey &dict_key) const

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

StringDictionaryProxy *	getStringDictionaryProxy (const shared::StringDictKey &dict_key) 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

bool	checkSlotUsesFlatBufferFormat (const size_t slot_idx) const

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

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

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

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

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

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

static bool	isNullIval (SQLTypeInfo const &, bool const translate_strings, int64_t const ival)

static ScalarTargetValue	nullScalarTargetValue (SQLTypeInfo const &, bool const translate_strings)

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	ModeBuffers = std::vector< std::vector< int64_t >>

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

Private Member Functions
void	advanceCursorToNextEntry (ResultSetRowIterator &iter) const

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

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

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

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

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

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

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

size_t	binSearchRowCount () const

size_t	parallelRowCount () const

size_t	advanceCursorToNextEntry () const

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

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

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

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

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

ScalarTargetValue	makeStringTargetValue (SQLTypeInfo const &chosen_type, bool const translate_strings, int64_t const ival) 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 ExecutorDeviceType device_type, 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_

const int	thread_idx_

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_

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 157 of file ResultSet.h.

Member Typedef Documentation

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

private

Definition at line 829 of file ResultSet.h.

using ResultSet::ModeBuffers = std::vector<std::vector<int64_t>>

private

Definition at line 830 of file ResultSet.h.

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

private

Definition at line 977 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 542 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 unsigned	block_size,
		const unsigned	grid_size
	)

Definition at line 64 of file ResultSet.cpp.

     : targets_(targets)
     , device_type_(device_type)
     , device_id_(-1)
     , thread_idx_(-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)
     , 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 int	thread_idx,
		const QueryMemoryDescriptor &	query_mem_desc,
		const std::shared_ptr< RowSetMemoryOwner >	row_set_mem_owner,
		const unsigned	block_size,
		const unsigned	grid_size
	)

Definition at line 93 of file ResultSet.cpp.

     : targets_(targets)
     , device_type_(device_type)
     , device_id_(device_id)
     , thread_idx_(thread_idx)
     , 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)
     , 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 165 of file ResultSet.cpp.

References CPU.

     : device_type_(ExecutorDeviceType::CPU)
     , device_id_(-1)
     , thread_idx_(-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 181 of file ResultSet.cpp.

References CPU.

     : device_type_(ExecutorDeviceType::CPU)
     , device_id_(-1)
     , thread_idx_(-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 200 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 724 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 303 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 585 of file ResultSet.h.

References anonymous_namespace{QueryMemoryDescriptor.cpp}::any_of(), and 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);
   }

Here is the call graph for this function:

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

private

size_t ResultSet::binSearchRowCount ( ) const

private

Definition at line 622 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 1047 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 522 of file ResultSet.h.

References can_use_speculative_top_n_sort.

                                                       {
     return can_use_speculative_top_n_sort;
   }

bool ResultSet::checkSlotUsesFlatBufferFormat ( const size_t slot_idx ) const

inline

Definition at line 633 of file ResultSet.h.

References QueryMemoryDescriptor::checkSlotUsesFlatBufferFormat(), and query_mem_desc_.

                                                                   {
     return query_mem_desc_.checkSlotUsesFlatBufferFormat(slot_idx);
   }

Here is the call graph for this function:

void ResultSet::clearPermutation ( )

inline

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

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

ScalarTargetValue ResultSet::convertToScalarTargetValue	(	SQLTypeInfo const &	ti,
		bool const	translate_strings,
		int64_t const	val
	)		const

Definition at line 1088 of file ResultSetIteration.cpp.

References CHECK_EQ, SQLTypeInfo::get_compression(), SQLTypeInfo::is_any(), SQLTypeInfo::is_string(), kDOUBLE, kENCODING_DICT, kFLOAT, and makeStringTargetValue().

Referenced by makeTargetValue().

                                                                                  {
   if (ti.is_string()) {
     CHECK_EQ(kENCODING_DICT, ti.get_compression());
     return makeStringTargetValue(ti, translate_strings, val);
   } else {
     return ti.is_any<kDOUBLE>()  ? ScalarTargetValue(shared::bit_cast<double>(val))
            : ti.is_any<kFLOAT>() ? ScalarTargetValue(shared::bit_cast<float>(val))
                                  : ScalarTargetValue(val);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ResultSetPtr ResultSet::copy ( )

Definition at line 333 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->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 1171 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 877 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 674 of file ResultSet.cpp.

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

bool ResultSet::didOutputColumnar ( ) const

inline

Definition at line 560 of file ResultSet.h.

References QueryMemoryDescriptor::didOutputColumnar(), and query_mem_desc_.

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

ResultSet::query_mem_desc_

QueryMemoryDescriptor query_mem_desc_

Definition: ResultSet.h:947

QueryMemoryDescriptor::didOutputColumnar

bool didOutputColumnar() const

Definition: QueryMemoryDescriptor.h:285

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 59 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 491 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 429 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 951 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 766 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:

unsigned ResultSet::getBlockSize ( ) const

inline

Definition at line 535 of file ResultSet.h.

References block_size_.

535 { return block_size_; }

ResultSet::block_size_

unsigned block_size_

Definition: ResultSet.h:957

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 420 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 1343 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 1508 of file ResultSet.cpp.

References CHECK.

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

const size_t ResultSet::getColumnarBufferSize ( size_t column_idx ) const

Definition at line 1513 of file ResultSet.cpp.

                                                                      {
   const auto col_context = query_mem_desc_.getColSlotContext();
   const auto idx = col_context.getSlotsForCol(column_idx).front();
   return query_mem_desc_.getPaddedSlotBufferSize(idx);
   if (checkSlotUsesFlatBufferFormat(idx)) {
     return query_mem_desc_.getFlatBufferSize(idx);
   }
   const size_t padded_slot_width = static_cast<size_t>(getPaddedSlotWidthBytes(idx));
   return padded_slot_width * entryCount();
 }

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 1289 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 1136 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 295 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 692 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 758 of file ResultSet.cpp.

                                  {
   return device_id_;
 }

ExecutorDeviceType ResultSet::getDeviceType ( ) const

Definition at line 254 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 1213 of file ResultSetIteration.cpp.

References heavyai::GroupByBaselineHash, heavyai::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 502 of file ResultSet.h.

References query_exec_time_.

502 { return query_exec_time_; }

ResultSet::query_exec_time_

size_t query_exec_time_

Definition: ResultSet.h:993

const Executor* ResultSet::getExecutor ( ) const

inline

Definition at line 631 of file ResultSet.h.

References QueryMemoryDescriptor::getExecutor(), and query_mem_desc_.

631 { return query_mem_desc_.getExecutor(); }

ResultSet::query_mem_desc_

QueryMemoryDescriptor query_mem_desc_

Definition: ResultSet.h:947

QueryMemoryDescriptor::getExecutor

const Executor * getExecutor() const

Definition: QueryMemoryDescriptor.h:171

Here is the call graph for this function:

std::string ResultSet::getExplanation ( ) const

inline

Definition at line 393 of file ResultSet.h.

References explanation_, and just_explain_.

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

GeoReturnType ResultSet::getGeoReturnType ( ) const

inline

Definition at line 551 of file ResultSet.h.

References geo_return_type_.

551 { return geo_return_type_; }

ResultSet::geo_return_type_

GeoReturnType geo_return_type_

Definition: ResultSet.h:988

int ResultSet::getGpuCount ( ) const

private

unsigned ResultSet::getGridSize ( ) const

inline

Definition at line 537 of file ResultSet.h.

References grid_size_.

537 { return grid_size_; }

ResultSet::grid_size_

unsigned grid_size_

Definition: ResultSet.h:958

int8_t * ResultSet::getHostEstimatorBuffer ( ) const

Definition at line 698 of file ResultSet.cpp.

                                                 {
   return host_estimator_buffer_;
 }

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

inline

Definition at line 508 of file ResultSet.h.

References input_table_keys_.

508 { return input_table_keys_; }

ResultSet::input_table_keys_

std::unordered_set< size_t > input_table_keys_

Definition: ResultSet.h:995

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

inline

Definition at line 581 of file ResultSet.h.

References lazy_fetch_info_.

                                                                  {
     return lazy_fetch_info_;
   }

size_t ResultSet::getLimit ( ) const

Definition at line 1409 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 296 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 318 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 305 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 590 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 234 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 570 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 874 of file ResultSet.cpp.

                                                          {
   return permutation_;
 }

QueryDescriptionType ResultSet::getQueryDescriptionType ( ) const

inline

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

References CHECK.

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

const QueryPlanHash ResultSet::getQueryPlanHash ( )

inline

Definition at line 506 of file ResultSet.h.

References query_plan_.

506 { return query_plan_; }

ResultSet::query_plan_

QueryPlanHash query_plan_

Definition: ResultSet.h:994

int64_t ResultSet::getQueueTime ( ) const

Definition at line 728 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 733 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 273 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 450 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 1321 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 1304 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 1525 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 1569 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 412 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 926 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:

std::string ResultSet::getString	(	SQLTypeInfo const &	ti,
		int64_t const	ival
	)		const

Definition at line 2057 of file ResultSetIteration.cpp.

References StringDictionaryProxy::getString(), SQLTypeInfo::getStringDictKey(), and row_set_mem_owner_.

Referenced by anonymous_namespace{ResultSetIteration.cpp}::build_string_array_target_value(), isLessThan(), and makeStringTargetValue().

                                                                               {
   const auto& dict_key = ti.getStringDictKey();
   StringDictionaryProxy* sdp;
   if (dict_key.dict_id) {
     constexpr bool with_generation = false;
     sdp = dict_key.db_id > 0
               ? row_set_mem_owner_->getOrAddStringDictProxy(dict_key, with_generation)
               : row_set_mem_owner_->getStringDictProxy(
                     dict_key);  // unit tests bypass the catalog
   } else {
     sdp = row_set_mem_owner_->getLiteralStringDictProxy();
   }
   return sdp->getString(ival);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const std::vector< std::string > ResultSet::getStringDictionaryPayloadCopy ( const shared::StringDictKey & dict_key ) const

Definition at line 1413 of file ResultSet.cpp.

References CHECK.

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

StringDictionaryProxy * ResultSet::getStringDictionaryProxy ( const shared::StringDictKey & dict_key ) const

Definition at line 429 of file ResultSet.cpp.

References shared::StringDictKey::db_id, shared::StringDictKey::dict_id, and dict_ref_t::literalsDictId.

                                                {
   constexpr bool with_generation = true;
   return (dict_key.db_id > 0 || dict_key.dict_id == DictRef::literalsDictId)
              ? row_set_mem_owner_->getOrAddStringDictProxy(dict_key, with_generation)
              : row_set_mem_owner_->getStringDictProxy(dict_key);
 }

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

References CHECK, CHECK_GE, is_distinct_target(), 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) ||
          shared::is_any<kAPPROX_QUANTILE, kMODE>(target.agg_kind) ||
          (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 683 of file ResultSet.cpp.

                                                              {
   return targets_;
 }

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

Definition at line 687 of file ResultSet.cpp.

References CHECK.

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

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

inline

Definition at line 520 of file ResultSet.h.

References target_meta_info_.

520 { return target_meta_info_; }

ResultSet::target_meta_info_

std::vector< TargetMetaInfo > target_meta_info_

Definition: ResultSet.h:996

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 2266 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(), getTargetValueFromFlatBuffer(), TargetInfo::is_agg, SQLTypeInfo::is_geometry(), is_real_str_or_array(), FlatBufferManager::isFlatBuffer(), kAVG, anonymous_namespace{ResultSetIteration.cpp}::make_avg_target_value(), makeGeoTargetValue(), makeTargetValue(), makeVarlenTargetValue(), query_mem_desc_, TargetInfo::sql_type, QueryMemoryDescriptor::targetGroupbyIndicesSize(), and SQLTypeInfo::usesFlatBuffer().

                                         {
   CHECK(query_mem_desc_.didOutputColumnar());
   const auto col1_ptr = col_ptr;
   if (target_info.sql_type.usesFlatBuffer()) {
     CHECK(FlatBufferManager::isFlatBuffer(col_ptr))
         << "target_info.sql_type=" << target_info.sql_type;
     return getTargetValueFromFlatBuffer(col_ptr,
                                         target_info,
                                         slot_idx,
                                         target_logical_idx,
                                         global_entry_idx,
                                         local_entry_idx,
                                         translate_strings,
                                         row_set_mem_owner_);
   }
   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 2350 of file ResultSetIteration.cpp.

                                                     {
   // FlatBuffer can exists only in a columnar storage. If the
   // following check fails it means that storage specific attributes
   // of type info have leaked.
   CHECK(!target_info.sql_type.usesFlatBuffer());
 
   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();
           constexpr size_t thread_idx{0};
           row_set_mem_owner_->initCountDistinctBufferAllocator(bitmap_byte_sz,
                                                                thread_idx);
           auto count_distinct_buffer =
               row_set_mem_owner_->allocateCountDistinctBuffer(bitmap_byte_sz, thread_idx);
           *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:

int ResultSet::getThreadIdx ( ) const

Definition at line 762 of file ResultSet.cpp.

References thread_idx_().

                                   {
   return thread_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 1422 of file ResultSet.cpp.

References CHECK, and inline_fixed_encoding_null_val().

                                                                              {
   const auto col_type_info = getColType(col_idx);
   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;
   CHECK(col_type_info.is_dict_encoded_type());  // Array<Text> or Text
   const int64_t null_val = inline_fixed_encoding_null_val(
       col_type_info.is_array() ? col_type_info.get_elem_type() : 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()) {
       if (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);
         }
       } else if (const auto array_col_val =
                      boost::get<ArrayTargetValue>(&result_row[col_idx])) {
         if (*array_col_val) {
           for (const ScalarTargetValue& scalar : array_col_val->value()) {
             const int32_t string_id = static_cast<int32_t>(boost::get<int64_t>(scalar));
             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 auto sdp = row_set_mem_owner_->getOrAddStringDictProxy(
       col_type_info.getStringDictKey(), /*with_generation=*/true);
   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 1161 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 528 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 443 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 440 of file ResultSet.h.

References chunks_.

                                                                        {
     chunks_ = chunks;
   }

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

inline

Definition at line 446 of file ResultSet.h.

References literal_buffers_.

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

void ResultSet::initializeStorage ( ) const

Definition at line 1042 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 858 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 473 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 611 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 485 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 498 of file ResultSet.h.

References cached_.

498 { return cached_; }

ResultSet::cached_

bool cached_

Definition: ResultSet.h:991

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

References CHECK, g_enable_direct_columnarization, heavyai::GroupByBaselineHash, heavyai::GroupByPerfectHash, heavyai::Projection, and heavyai::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 655 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 494 of file ResultSet.h.

References estimator_.

494 { return !estimator_; }

ResultSet::estimator_

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

Definition: ResultSet.h:971

bool ResultSet::isExplain ( ) const

Definition at line 746 of file ResultSet.cpp.

                                 {
   return just_explain_;
 }

bool ResultSet::isGeoColOnGpu ( const size_t col_idx ) const

Definition at line 1489 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::isLessThan	(	SQLTypeInfo const &	ti,
		int64_t const	lhs,
		int64_t const	rhs
	)		const

Definition at line 1111 of file ResultSetIteration.cpp.

References shared::bit_cast(), CHECK_EQ, SQLTypeInfo::get_compression(), getString(), SQLTypeInfo::is_any(), SQLTypeInfo::is_string(), kDOUBLE, kENCODING_DICT, and kFLOAT.

                                                     {
   if (ti.is_string()) {
     CHECK_EQ(kENCODING_DICT, ti.get_compression());
     return getString(ti, lhs) < getString(ti, rhs);
   } else {
     return ti.is_any<kDOUBLE>()
                ? shared::bit_cast<double>(lhs) < shared::bit_cast<double>(rhs)
            : ti.is_any<kFLOAT>()
                ? shared::bit_cast<float>(lhs) < shared::bit_cast<float>(rhs)
                : lhs < rhs;
   }
 }

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

bool ResultSet::isNullIval	(	SQLTypeInfo const &	ti,
		bool const	translate_strings,
		int64_t const	ival
	)

static

Definition at line 1126 of file ResultSetIteration.cpp.

References inline_int_null_val(), SQLTypeInfo::is_any(), SQLTypeInfo::is_string(), kDOUBLE, kFLOAT, NULL_DOUBLE, NULL_FLOAT, and NULL_INT.

Referenced by makeTargetValue().

                                                {
   return ti.is_any<kDOUBLE>()  ? shared::bit_cast<double>(ival) == NULL_DOUBLE
          : ti.is_any<kFLOAT>() ? shared::bit_cast<float>(ival) == NULL_FLOAT
          : ti.is_string()      ? translate_strings ? ival == NULL_INT : ival == 0
                                : ival == inline_int_null_val(ti);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const bool ResultSet::isPermutationBufferEmpty ( ) const

inline

Definition at line 455 of file ResultSet.h.

References permutation_.

455 { return permutation_.empty(); };

ResultSet::permutation_

Permutation permutation_

Definition: ResultSet.h:955

bool ResultSet::isRowAtEmpty ( const size_t index ) const

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

                                   {
   return keep_first_ + drop_first_;
 }

bool ResultSet::isValidationOnlyRes ( ) const

Definition at line 754 of file ResultSet.cpp.

                                           {
   return for_validation_only_;
 }

bool ResultSet::isZeroCopyColumnarConversionPossible ( size_t column_idx ) const

Definition at line 1499 of file ResultSet.cpp.

References heavyai::Projection, and heavyai::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 54 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 1652 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, FlatBufferManager::isFlatBuffer(), kENCODING_GEOINT, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kPOINT, kPOLYGON, lazy_fetch_info_, ColumnLazyFetchInfo::local_col_id, NestedArrayToGeoTargetValue(), 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 kMULTIPOINT: {
       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<kMULTIPOINT, 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();
 
         auto ptr = frag_col_buffers[col_lazy_fetch->local_col_id];
         if (FlatBufferManager::isFlatBuffer(ptr)) {
           int64_t index = getCoordsDataPtr(geo_target_ptr);
           return NestedArrayToGeoTargetValue<1,
                                              Geospatial::GeoMultiPoint,
                                              GeoMultiPointTargetValue,
                                              GeoMultiPointTargetValuePtr>(
               ptr, index, target_info.sql_type, geo_return_type_);
         }
         return GeoTargetValueBuilder<kMULTIPOINT, 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<kMULTIPOINT, 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();
 
         auto ptr = frag_col_buffers[col_lazy_fetch->local_col_id];
         if (FlatBufferManager::isFlatBuffer(ptr)) {
           int64_t index = getCoordsDataPtr(geo_target_ptr);
           return NestedArrayToGeoTargetValue<1,
                                              Geospatial::GeoLineString,
                                              GeoLineStringTargetValue,
                                              GeoLineStringTargetValuePtr>(
               ptr, index, target_info.sql_type, geo_return_type_);
         }
         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 kMULTILINESTRING: {
       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<kMULTILINESTRING, 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();
 
         auto ptr = frag_col_buffers[col_lazy_fetch->local_col_id];
         if (FlatBufferManager::isFlatBuffer(ptr)) {
           int64_t index = getCoordsDataPtr(geo_target_ptr);
           return NestedArrayToGeoTargetValue<2,
                                              Geospatial::GeoMultiLineString,
                                              GeoMultiLineStringTargetValue,
                                              GeoMultiLineStringTargetValuePtr>(
               ptr, index, target_info.sql_type, geo_return_type_);
         }
 
         return GeoTargetValueBuilder<kMULTILINESTRING, 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<kMULTILINESTRING, 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 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();
         auto ptr = frag_col_buffers[col_lazy_fetch->local_col_id];
         if (FlatBufferManager::isFlatBuffer(ptr)) {
           int64_t index = getCoordsDataPtr(geo_target_ptr);
           return NestedArrayToGeoTargetValue<2,
                                              Geospatial::GeoPolygon,
                                              GeoPolyTargetValue,
                                              GeoPolyTargetValuePtr>(
               ptr, index, target_info.sql_type, geo_return_type_);
         }
 
         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();
         auto ptr = frag_col_buffers[col_lazy_fetch->local_col_id];
         if (FlatBufferManager::isFlatBuffer(ptr)) {
           int64_t index = getCoordsDataPtr(geo_target_ptr);
           return NestedArrayToGeoTargetValue<3,
                                              Geospatial::GeoMultiPolygon,
                                              GeoMultiPolyTargetValue,
                                              GeoMultiPolyTargetValuePtr>(
               ptr, index, target_info.sql_type, geo_return_type_);
         }
 
         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:

ScalarTargetValue ResultSet::makeStringTargetValue	(	SQLTypeInfo const &	chosen_type,
		bool const	translate_strings,
		int64_t const	ival
	)		const

private

Definition at line 2072 of file ResultSetIteration.cpp.

References getString(), and NULL_INT.

Referenced by convertToScalarTargetValue(), and makeTargetValue().

                                                                              {
   if (translate_strings) {
     if (static_cast<int32_t>(ival) == NULL_INT) {  // TODO(alex): this isn't nice, fix it
       return NullableString(nullptr);
     } else {
       return NullableString(getString(chosen_type, ival));
     }
   } else {
     return static_cast<int64_t>(static_cast<int32_t>(ival));
   }
 }

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

References TargetInfo::agg_kind, calculateQuantile(), CHECK, CHECK_EQ, CHECK_GE, CHECK_LT, col_buffers_, convertToScalarTargetValue(), 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(), isNullIval(), kAPPROX_QUANTILE, kAVG, kBIGINT, kENCODING_DICT, kFLOAT, kMAX, kMIN, kMODE, kSINGLE_VALUE, kSUM, kSUM_IF, result_set::lazy_decode(), lazy_fetch_info_, makeStringTargetValue(), NULL_DOUBLE, nullScalarTargetValue(), query_mem_desc_, read_int_from_buff(), 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 == kSUM_IF || 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.getStringDictKey().dict_id) {
     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 (target_info.agg_kind == kMODE) {
     if (!isNullIval(chosen_type, translate_strings, ival)) {
       auto const* const* const agg_mode = reinterpret_cast<AggMode const* const*>(ptr);
       if (std::optional<int64_t> const mode = (*agg_mode)->mode()) {
         return convertToScalarTargetValue(chosen_type, translate_strings, *mode);
       }
     }
     return nullScalarTargetValue(chosen_type, translate_strings);
   }
   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) {
     return makeStringTargetValue(chosen_type, translate_strings, 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 == kSUM_IF || 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 1358 of file ResultSetIteration.cpp.

References anonymous_namespace{ResultSetIteration.cpp}::build_array_target_value(), 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, is_null(), SQLTypeInfo::is_string(), FlatBufferManager::isFlatBuffer(), 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_, TargetInfo::sql_type, and VarlenArray_get_nth().

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_);
     } 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};
       auto col_buf = const_cast<int8_t*>(frag_col_buffers[col_lazy_fetch.local_col_id]);
       if (target_info.sql_type.is_string()) {
         if (FlatBufferManager::isFlatBuffer(col_buf)) {
           FlatBufferManager m{col_buf};
           std::string fetched_str;
           bool is_null{};
           auto status = m.getItem(varlen_ptr, fetched_str, is_null);
           if (is_null) {
             return TargetValue(nullptr);
           }
           CHECK_EQ(status, FlatBufferManager::Status::Success);
           return fetched_str;
         }
         VarlenDatum vd;
         ChunkIter_get_nth(
             reinterpret_cast<ChunkIter*>(col_buf), 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;
         if (FlatBufferManager::isFlatBuffer(col_buf)) {
           VarlenArray_get_nth(col_buf, varlen_ptr, &ad, &is_end);
         } else {
           ChunkIter_get_nth(
               reinterpret_cast<ChunkIter*>(col_buf), varlen_ptr, &ad, &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_);
       }
     }
   }
   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_);
   }
   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 737 of file ResultSet.cpp.

                                   {
   crt_row_buff_idx_ = 0;
   fetched_so_far_ = 0;
 }

ScalarTargetValue ResultSet::nullScalarTargetValue	(	SQLTypeInfo const &	ti,
		bool const	translate_strings
	)

static

Definition at line 1101 of file ResultSetIteration.cpp.

References inline_int_null_val(), SQLTypeInfo::is_any(), SQLTypeInfo::is_string(), kDOUBLE, kFLOAT, NULL_DOUBLE, NULL_FLOAT, and NULL_INT.

Referenced by makeTargetValue().

                                                                                  {
   return ti.is_any<kDOUBLE>()  ? ScalarTargetValue(NULL_DOUBLE)
          : ti.is_any<kFLOAT>() ? ScalarTargetValue(NULL_FLOAT)
          : ti.is_string()      ? translate_strings
                                      ? ScalarTargetValue(NullableString(nullptr))
                                      : ScalarTargetValue(static_cast<int64_t>(NULL_INT))
                                : ScalarTargetValue(inline_int_null_val(ti));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t ResultSet::parallelRowCount ( ) const

private

Definition at line 635 of file ResultSet.cpp.

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

                                          {
   using namespace threading;
   auto execute_parallel_row_count =
       [this, parent_thread_local_ids = logger::thread_local_ids()](
           const blocked_range<size_t>& r, size_t row_count) {
         logger::LocalIdsScopeGuard lisg = parent_thread_local_ids.setNewThreadId();
         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 878 of file ResultSet.cpp.

References gpu_enabled::copy(), cpu_threads(), DEBUG_TIMER, threading_std::task_group::run(), logger::thread_local_ids(), 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,
                           parent_thread_local_ids = logger::thread_local_ids(),
                           interval] {
       logger::LocalIdsScopeGuard lisg = parent_thread_local_ids.setNewThreadId();
       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 1369 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 1329 of file ResultSet.cpp.

References CHECK_GT, copy_group_by_buffers_from_gpu(), create_dev_group_by_buffers(), DEBUG_TIMER, Catalog_Namespace::SysCatalog::getDataMgr(), getQueryEngineCudaStreamForDevice(), GPU, inplace_sort_gpu(), Catalog_Namespace::SysCatalog::instance(), and KernelPerFragment.

                                                             {
   auto timer = DEBUG_TIMER(__func__);
   auto data_mgr = &Catalog_Namespace::SysCatalog::instance().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);
 }

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