#include <RowSetMemoryOwner.h>

Inheritance diagram for RowSetMemoryOwner:

Collaboration diagram for RowSetMemoryOwner:

Classes
struct	CountDistinctBitmapBuffer

Public Types
enum	StringTranslationType { StringTranslationType::SOURCE_INTERSECTION, StringTranslationType::SOURCE_UNION }

Public Member Functions
	RowSetMemoryOwner (const size_t arena_block_size, const size_t num_kernel_threads=0)

int8_t *	allocate (const size_t num_bytes, const size_t thread_idx=0) override

int8_t *	allocateCountDistinctBuffer (const size_t num_bytes, const size_t thread_idx=0)

void	addCountDistinctBuffer (int8_t *count_distinct_buffer, const size_t bytes, const bool physical_buffer)

void	addCountDistinctSet (CountDistinctSet *count_distinct_set)

void	addGroupByBuffer (int64_t *group_by_buffer)

void	addVarlenBuffer (void *varlen_buffer)

void	addVarlenInputBuffer (Data_Namespace::AbstractBuffer *buffer)

std::string *	addString (const std::string &str)

std::vector< int64_t > *	addArray (const std::vector< int64_t > &arr)

StringDictionaryProxy *	addStringDict (std::shared_ptr< StringDictionary > str_dict, const int dict_id, const int64_t generation)

std::string	generate_translation_map_key (const int32_t source_proxy_id, const int32_t dest_proxy_id, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos)

const StringDictionaryProxy::IdMap *	addStringProxyIntersectionTranslationMap (const StringDictionaryProxy source_proxy, const StringDictionaryProxy dest_proxy, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos)

const StringDictionaryProxy::IdMap *	addStringProxyUnionTranslationMap (const StringDictionaryProxy source_proxy, StringDictionaryProxy dest_proxy, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos)

const StringOps_Namespace::StringOps *	getStringOps (const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos)

StringDictionaryProxy *	getStringDictProxy (const int dict_id) const

StringDictionaryProxy *	getOrAddStringDictProxy (const int dict_id_in, const bool with_generation, const Catalog_Namespace::Catalog *catalog)

void	addLiteralStringDictProxy (std::shared_ptr< StringDictionaryProxy > lit_str_dict_proxy)

StringDictionaryProxy *	getLiteralStringDictProxy () const

const StringDictionaryProxy::IdMap *	getOrAddStringProxyTranslationMap (const int source_dict_id_in, const int dest_dict_id_in, const bool with_generation, const StringTranslationType translation_map_type, const std::vector< StringOps_Namespace::StringOpInfo > &string_op_infos, const Catalog_Namespace::Catalog *catalog)

void	addColBuffer (const void *col_buffer)

	~RowSetMemoryOwner ()

std::shared_ptr < RowSetMemoryOwner >	cloneStrDictDataOnly ()

void	setDictionaryGenerations (StringDictionaryGenerations generations)

StringDictionaryGenerations &	getStringDictionaryGenerations ()

quantile::TDigest *	nullTDigest (double const q)

void	setTableFunctionMetadata (const char key, const uint8_t raw_data, const size_t num_bytes, const TableFunctionMetadataType value_type)

void	getTableFunctionMetadata (const char key, const uint8_t &raw_data, size_t &num_bytes, TableFunctionMetadataType &value_type) const

Private Types
using	MetadataValue = std::pair< std::vector< uint8_t >, TableFunctionMetadataType >

Private Attributes
std::vector < CountDistinctBitmapBuffer >	count_distinct_bitmaps_

std::vector< CountDistinctSet * >	count_distinct_sets_

std::vector< int64_t * >	group_by_buffers_

std::vector< void * >	varlen_buffers_

std::list< std::string >	strings_

std::list< std::vector< int64_t > >	arrays_

std::unordered_map< int, std::shared_ptr < StringDictionaryProxy > >	str_dict_proxy_owned_

std::map< std::string, StringDictionaryProxy::IdMap >	str_proxy_intersection_translation_maps_owned_

std::map< std::string, StringDictionaryProxy::IdMap >	str_proxy_union_translation_maps_owned_

std::shared_ptr < StringDictionaryProxy >	lit_str_dict_proxy_

StringDictionaryGenerations	string_dictionary_generations_

std::vector< void * >	col_buffers_

std::vector < Data_Namespace::AbstractBuffer * >	varlen_input_buffers_

std::vector< std::unique_ptr < quantile::TDigest > >	t_digests_

std::map< std::string, std::shared_ptr < StringOps_Namespace::StringOps > >	string_ops_owned_

size_t	arena_block_size_

std::vector< std::unique_ptr < Arena > >	allocators_

std::mutex	state_mutex_

std::map< std::string, MetadataValue >	table_function_metadata_store_

std::mutex	table_function_metadata_store_mutex_

Friends
class	ResultSet

class	QueryExecutionContext

Additional Inherited Members
Protected Member Functions inherited from SimpleAllocator
	~SimpleAllocator ()=default

Detailed Description

Handles allocations and outputs for all stages in a query, either explicitly or via a managed allocator object

Definition at line 48 of file RowSetMemoryOwner.h.

Member Typedef Documentation

using RowSetMemoryOwner::MetadataValue = std::pair<std::vector<uint8_t>, TableFunctionMetadataType>

private

Definition at line 342 of file RowSetMemoryOwner.h.

Member Enumeration Documentation

enum RowSetMemoryOwner::StringTranslationType

strong

Enumerator
SOURCE_INTERSECTION
SOURCE_UNION

Definition at line 58 of file RowSetMemoryOwner.h.

58 { SOURCE_INTERSECTION, SOURCE_UNION };

Constructor & Destructor Documentation

RowSetMemoryOwner::RowSetMemoryOwner	(	const size_t	arena_block_size,
		const size_t	num_kernel_threads = `0`
	)

inline

Definition at line 50 of file RowSetMemoryOwner.h.

References allocators_, and CHECK.

       : arena_block_size_(arena_block_size) {
     for (size_t i = 0; i < num_kernel_threads + 1; i++) {
       allocators_.emplace_back(std::make_unique<DramArena>(arena_block_size));
     }
     CHECK(!allocators_.empty());
   }

RowSetMemoryOwner::~RowSetMemoryOwner ( )

inline

Definition at line 246 of file RowSetMemoryOwner.h.

References CHECK, col_buffers_, count_distinct_sets_, group_by_buffers_, varlen_buffers_, and varlen_input_buffers_.

                        {
     for (auto count_distinct_set : count_distinct_sets_) {
       delete count_distinct_set;
     }
     for (auto group_by_buffer : group_by_buffers_) {
       free(group_by_buffer);
     }
     for (auto varlen_buffer : varlen_buffers_) {
       free(varlen_buffer);
     }
     for (auto varlen_input_buffer : varlen_input_buffers_) {
       CHECK(varlen_input_buffer);
       varlen_input_buffer->unPin();
     }
     for (auto col_buffer : col_buffers_) {
       free(col_buffer);
     }
   }

Member Function Documentation

std::vector<int64_t>* RowSetMemoryOwner::addArray ( const std::vector< int64_t > & arr )

inline

Definition at line 118 of file RowSetMemoryOwner.h.

References arrays_, and state_mutex_.

                                                               {
     std::lock_guard<std::mutex> lock(state_mutex_);
     arrays_.emplace_back(arr);
     return &arrays_.back();
   }

void RowSetMemoryOwner::addColBuffer ( const void * col_buffer )

inline

Definition at line 241 of file RowSetMemoryOwner.h.

References col_buffers_, and state_mutex_.

                                             {
     std::lock_guard<std::mutex> lock(state_mutex_);
     col_buffers_.push_back(const_cast<void*>(col_buffer));
   }

void RowSetMemoryOwner::addCountDistinctBuffer	(	int8_t *	count_distinct_buffer,
		const size_t	bytes,
		const bool	physical_buffer
	)

inline

Definition at line 75 of file RowSetMemoryOwner.h.

References count_distinct_bitmaps_, and state_mutex_.

Referenced by allocateCountDistinctBuffer().

                                                           {
     std::lock_guard<std::mutex> lock(state_mutex_);
     count_distinct_bitmaps_.emplace_back(
         CountDistinctBitmapBuffer{count_distinct_buffer, bytes, physical_buffer});
   }

Here is the caller graph for this function:

void RowSetMemoryOwner::addCountDistinctSet ( CountDistinctSet * count_distinct_set )

inline

Definition at line 83 of file RowSetMemoryOwner.h.

References count_distinct_sets_, and state_mutex_.

                                                                  {
     std::lock_guard<std::mutex> lock(state_mutex_);
     count_distinct_sets_.push_back(count_distinct_set);
   }

void RowSetMemoryOwner::addGroupByBuffer ( int64_t * group_by_buffer )

inline

Definition at line 88 of file RowSetMemoryOwner.h.

References group_by_buffers_, and state_mutex_.

                                                   {
     std::lock_guard<std::mutex> lock(state_mutex_);
     group_by_buffers_.push_back(group_by_buffer);
   }

void RowSetMemoryOwner::addLiteralStringDictProxy ( std::shared_ptr< StringDictionaryProxy > lit_str_dict_proxy )

inline

Definition at line 222 of file RowSetMemoryOwner.h.

References lit_str_dict_proxy_, and state_mutex_.

                                                                {
     std::lock_guard<std::mutex> lock(state_mutex_);
     lit_str_dict_proxy_ = lit_str_dict_proxy;
   }

std::string* RowSetMemoryOwner::addString ( const std::string & str )

inline

Definition at line 112 of file RowSetMemoryOwner.h.

References state_mutex_, and strings_.

                                              {
     std::lock_guard<std::mutex> lock(state_mutex_);
     strings_.emplace_back(str);
     return &strings_.back();
   }

StringDictionaryProxy* RowSetMemoryOwner::addStringDict	(	std::shared_ptr< StringDictionary >	str_dict,
		const int	dict_id,
		const int64_t	generation
	)

inline

Definition at line 124 of file RowSetMemoryOwner.h.

References CHECK_EQ, state_mutex_, and str_dict_proxy_owned_.

                                                                  {
     std::lock_guard<std::mutex> lock(state_mutex_);
     auto it = str_dict_proxy_owned_.find(dict_id);
     if (it != str_dict_proxy_owned_.end()) {
       CHECK_EQ(it->second->getDictionary(), str_dict.get());
       it->second->updateGeneration(generation);
       return it->second.get();
     }
     it = str_dict_proxy_owned_
              .emplace(
                  dict_id,
                  std::make_shared<StringDictionaryProxy>(str_dict, dict_id, generation))
              .first;
     return it->second.get();
   }

const StringDictionaryProxy::IdMap* RowSetMemoryOwner::addStringProxyIntersectionTranslationMap	(	const StringDictionaryProxy *	source_proxy,
		const StringDictionaryProxy *	dest_proxy,
		const std::vector< StringOps_Namespace::StringOpInfo > &	string_op_infos
	)

inline

Definition at line 156 of file RowSetMemoryOwner.h.

References StringDictionaryProxy::buildIntersectionTranslationMapToOtherProxy(), generate_translation_map_key(), StringDictionary::getDictId(), StringDictionaryProxy::getDictionary(), state_mutex_, and str_proxy_intersection_translation_maps_owned_.

                                                                          {
     std::lock_guard<std::mutex> lock(state_mutex_);
     const auto map_key =
         generate_translation_map_key(source_proxy->getDictionary()->getDictId(),
                                      dest_proxy->getDictionary()->getDictId(),
                                      string_op_infos);
     auto it = str_proxy_intersection_translation_maps_owned_.find(map_key);
     if (it == str_proxy_intersection_translation_maps_owned_.end()) {
       it = str_proxy_intersection_translation_maps_owned_
                .emplace(map_key,
                         source_proxy->buildIntersectionTranslationMapToOtherProxy(
                             dest_proxy, string_op_infos))
                .first;
     }
     return &it->second;
   }

Here is the call graph for this function:

const StringDictionaryProxy::IdMap* RowSetMemoryOwner::addStringProxyUnionTranslationMap	(	const StringDictionaryProxy *	source_proxy,
		StringDictionaryProxy *	dest_proxy,
		const std::vector< StringOps_Namespace::StringOpInfo > &	string_op_infos
	)

inline

Definition at line 176 of file RowSetMemoryOwner.h.

References StringDictionaryProxy::buildUnionTranslationMapToOtherProxy(), generate_translation_map_key(), StringDictionary::getDictId(), StringDictionaryProxy::getDictionary(), state_mutex_, and str_proxy_union_translation_maps_owned_.

                                                                          {
     std::lock_guard<std::mutex> lock(state_mutex_);
     const auto map_key =
         generate_translation_map_key(source_proxy->getDictionary()->getDictId(),
                                      dest_proxy->getDictionary()->getDictId(),
                                      string_op_infos);
     auto it = str_proxy_union_translation_maps_owned_.find(map_key);
     if (it == str_proxy_union_translation_maps_owned_.end()) {
       it = str_proxy_union_translation_maps_owned_
                .emplace(map_key,
                         source_proxy->buildUnionTranslationMapToOtherProxy(
                             dest_proxy, string_op_infos))
                .first;
     }
     return &it->second;
   }

Here is the call graph for this function:

void RowSetMemoryOwner::addVarlenBuffer ( void * varlen_buffer )

inline

Definition at line 93 of file RowSetMemoryOwner.h.

References state_mutex_, and varlen_buffers_.

                                             {
     std::lock_guard<std::mutex> lock(state_mutex_);
     if (std::find(varlen_buffers_.begin(), varlen_buffers_.end(), varlen_buffer) ==
         varlen_buffers_.end()) {
       varlen_buffers_.push_back(varlen_buffer);
     }
   }

void RowSetMemoryOwner::addVarlenInputBuffer ( Data_Namespace::AbstractBuffer * buffer )

inline

Adds a GPU buffer containing a variable length input column. Variable length inputs on GPU are referenced in output projected targets and should not be freed until the query results have been resolved.

Definition at line 106 of file RowSetMemoryOwner.h.

References CHECK_EQ, Data_Namespace::AbstractBuffer::getType(), Data_Namespace::GPU_LEVEL, state_mutex_, and varlen_input_buffers_.

                                                                   {
     std::lock_guard<std::mutex> lock(state_mutex_);
     CHECK_EQ(buffer->getType(), Data_Namespace::MemoryLevel::GPU_LEVEL);
     varlen_input_buffers_.push_back(buffer);
   }

Here is the call graph for this function:

int8_t* RowSetMemoryOwner::allocate	(	const size_t	num_bytes,
		const size_t	thread_idx = `0`
	)

inlineoverridevirtual

Implements SimpleAllocator.

Definition at line 60 of file RowSetMemoryOwner.h.

References allocators_, CHECK_LT, and state_mutex_.

Referenced by anonymous_namespace{QueryMemoryInitializer.cpp}::alloc_group_by_buffer(), and allocateCountDistinctBuffer().

                                                                                  {
     CHECK_LT(thread_idx, allocators_.size());
     auto allocator = allocators_[thread_idx].get();
     std::lock_guard<std::mutex> lock(state_mutex_);
     return reinterpret_cast<int8_t*>(allocator->allocate(num_bytes));
   }

Here is the caller graph for this function:

int8_t* RowSetMemoryOwner::allocateCountDistinctBuffer	(	const size_t	num_bytes,
		const size_t	thread_idx = `0`
	)

inline

Definition at line 67 of file RowSetMemoryOwner.h.

References addCountDistinctBuffer(), and allocate().

                                                                    {
     int8_t* buffer = allocate(num_bytes, thread_idx);
     std::memset(buffer, 0, num_bytes);
     addCountDistinctBuffer(buffer, num_bytes, /*physical_buffer=*/true);
     return buffer;
   }

Here is the call graph for this function:

std::shared_ptr<RowSetMemoryOwner> RowSetMemoryOwner::cloneStrDictDataOnly ( )

inline

Definition at line 265 of file RowSetMemoryOwner.h.

References arena_block_size_, lit_str_dict_proxy_, and str_dict_proxy_owned_.

                                                           {
     auto rtn = std::make_shared<RowSetMemoryOwner>(arena_block_size_, /*num_kernels=*/1);
     rtn->str_dict_proxy_owned_ = str_dict_proxy_owned_;
     rtn->lit_str_dict_proxy_ = lit_str_dict_proxy_;
     return rtn;
   }

std::string RowSetMemoryOwner::generate_translation_map_key	(	const int32_t	source_proxy_id,
		const int32_t	dest_proxy_id,
		const std::vector< StringOps_Namespace::StringOpInfo > &	string_op_infos
	)

inline

Definition at line 142 of file RowSetMemoryOwner.h.

Referenced by addStringProxyIntersectionTranslationMap(), addStringProxyUnionTranslationMap(), and getStringOps().

                                                                          {
     std::ostringstream oss;
     oss << "{source_dict_id: " << source_proxy_id << ", dest_dict_id: " << dest_proxy_id
         << " StringOps: " << string_op_infos << "}";
     // for (const auto& string_op_info : string_op_infos) {
     //  oss << "{" << string_op_info.toString() << "}";
     //}
     // oss << "]";
     return oss.str();
   }

Here is the caller graph for this function:

StringDictionaryProxy* RowSetMemoryOwner::getLiteralStringDictProxy ( ) const

inline

Definition at line 228 of file RowSetMemoryOwner.h.

References lit_str_dict_proxy_, and state_mutex_.

                                                            {
     std::lock_guard<std::mutex> lock(state_mutex_);
     return lit_str_dict_proxy_.get();
   }

StringDictionaryProxy * RowSetMemoryOwner::getOrAddStringDictProxy	(	const int	dict_id_in,
		const bool	with_generation,
		const Catalog_Namespace::Catalog *	catalog
	)

Definition at line 542 of file Execute.cpp.

References CHECK, CHECK_EQ, CHECK_LE, g_cache_string_hash, Catalog_Namespace::Catalog::getDatabaseId(), Catalog_Namespace::Catalog::getMetadataForDict(), dict_ref_t::literalsDictId, and REGULAR_DICT.

                                              {
   const int dict_id{dict_id_in < 0 ? REGULAR_DICT(dict_id_in) : dict_id_in};
   CHECK(catalog);
   const auto dd = catalog->getMetadataForDict(dict_id);
   if (dd) {
     CHECK(dd->stringDict);
     CHECK_LE(dd->dictNBits, 32);
     const int64_t generation =
         with_generation ? string_dictionary_generations_.getGeneration(dict_id) : -1;
     return addStringDict(dd->stringDict, dict_id, generation);
   }
   CHECK_EQ(dict_id, DictRef::literalsDictId);
   if (!lit_str_dict_proxy_) {
     DictRef literal_dict_ref(catalog->getDatabaseId(), DictRef::literalsDictId);
     std::shared_ptr<StringDictionary> tsd = std::make_shared<StringDictionary>(
         literal_dict_ref, "", false, true, g_cache_string_hash);
     lit_str_dict_proxy_ =
         std::make_shared<StringDictionaryProxy>(tsd, literal_dict_ref.dictId, 0);
   }
   return lit_str_dict_proxy_.get();
 }

Here is the call graph for this function:

const StringDictionaryProxy::IdMap * RowSetMemoryOwner::getOrAddStringProxyTranslationMap	(	const int	source_dict_id_in,
		const int	dest_dict_id_in,
		const bool	with_generation,
		const StringTranslationType	translation_map_type,
		const std::vector< StringOps_Namespace::StringOpInfo > &	string_op_infos,
		const Catalog_Namespace::Catalog *	catalog
	)

Definition at line 604 of file Execute.cpp.

References SOURCE_INTERSECTION.

                                              {
   const auto source_proxy =
       getOrAddStringDictProxy(source_dict_id_in, with_generation, catalog);
   auto dest_proxy = getOrAddStringDictProxy(dest_dict_id_in, with_generation, catalog);
   if (translation_type == RowSetMemoryOwner::StringTranslationType::SOURCE_INTERSECTION) {
     return addStringProxyIntersectionTranslationMap(
         source_proxy, dest_proxy, string_op_infos);
   } else {
     return addStringProxyUnionTranslationMap(source_proxy, dest_proxy, string_op_infos);
   }
 }

StringDictionaryGenerations& RowSetMemoryOwner::getStringDictionaryGenerations ( )

inline

Definition at line 276 of file RowSetMemoryOwner.h.

References string_dictionary_generations_.

                                                                 {
     return string_dictionary_generations_;
   }

StringDictionaryProxy* RowSetMemoryOwner::getStringDictProxy ( const int dict_id ) const

inline

Definition at line 210 of file RowSetMemoryOwner.h.

References CHECK, state_mutex_, and str_dict_proxy_owned_.

                                                                      {
     std::lock_guard<std::mutex> lock(state_mutex_);
     auto it = str_dict_proxy_owned_.find(dict_id);
     CHECK(it != str_dict_proxy_owned_.end());
     return it->second.get();
   }

const StringOps_Namespace::StringOps* RowSetMemoryOwner::getStringOps ( const std::vector< StringOps_Namespace::StringOpInfo > & string_op_infos )

inline

Definition at line 196 of file RowSetMemoryOwner.h.

References generate_translation_map_key(), state_mutex_, and string_ops_owned_.

                                                                          {
     std::lock_guard<std::mutex> lock(state_mutex_);
     const auto map_key = generate_translation_map_key(0, 0, string_op_infos);
     auto it = string_ops_owned_.find(map_key);
     if (it == string_ops_owned_.end()) {
       it = string_ops_owned_
                .emplace(map_key,
                         std::make_shared<StringOps_Namespace::StringOps>(string_op_infos))
                .first;
     }
     return it->second.get();
   }

Here is the call graph for this function:

void RowSetMemoryOwner::getTableFunctionMetadata	(	const char *	key,
		const uint8_t *&	raw_data,
		size_t &	num_bytes,
		TableFunctionMetadataType &	value_type
	)		const

inline

Definition at line 296 of file RowSetMemoryOwner.h.

References table_function_metadata_store_, and table_function_metadata_store_mutex_.

                                                                              {
     std::lock_guard<std::mutex> lock(table_function_metadata_store_mutex_);
     auto const itr = table_function_metadata_store_.find(key);
     if (itr == table_function_metadata_store_.end()) {
       throw std::runtime_error("Failed to find Table Function Metadata with key '" +
                                std::string(key) + "'");
     }
     raw_data = itr->second.first.data();
     num_bytes = itr->second.first.size();
     value_type = itr->second.second;
   }

quantile::TDigest * RowSetMemoryOwner::nullTDigest ( double const q )

Definition at line 622 of file Execute.cpp.

References g_approx_quantile_buffer, and g_approx_quantile_centroids.

                                                               {
   std::lock_guard<std::mutex> lock(state_mutex_);
   return t_digests_
       .emplace_back(std::make_unique<quantile::TDigest>(
           q, this, g_approx_quantile_buffer, g_approx_quantile_centroids))
       .get();
 }

void RowSetMemoryOwner::setDictionaryGenerations ( StringDictionaryGenerations generations )

inline

Definition at line 272 of file RowSetMemoryOwner.h.

References string_dictionary_generations_.

                                                                          {
     string_dictionary_generations_ = generations;
   }

void RowSetMemoryOwner::setTableFunctionMetadata	(	const char *	key,
		const uint8_t *	raw_data,
		const size_t	num_bytes,
		const TableFunctionMetadataType	value_type
	)

inline

Definition at line 286 of file RowSetMemoryOwner.h.

References table_function_metadata_store_, and table_function_metadata_store_mutex_.

                                                                             {
     MetadataValue metadata_value(num_bytes, value_type);
     std::memcpy(metadata_value.first.data(), raw_data, num_bytes);
     std::lock_guard<std::mutex> lock(table_function_metadata_store_mutex_);
     table_function_metadata_store_[key] = std::move(metadata_value);
   }

Friends And Related Function Documentation

friend class QueryExecutionContext

friend

Definition at line 347 of file RowSetMemoryOwner.h.

friend class ResultSet

friend

Definition at line 346 of file RowSetMemoryOwner.h.

Member Data Documentation

std::vector<std::unique_ptr<Arena> > RowSetMemoryOwner::allocators_

private

Definition at line 338 of file RowSetMemoryOwner.h.

Referenced by allocate(), and RowSetMemoryOwner().

size_t RowSetMemoryOwner::arena_block_size_

private

Definition at line 337 of file RowSetMemoryOwner.h.

Referenced by cloneStrDictDataOnly().

std::list<std::vector<int64_t> > RowSetMemoryOwner::arrays_

private

Definition at line 323 of file RowSetMemoryOwner.h.

Referenced by addArray().

std::vector<void*> RowSetMemoryOwner::col_buffers_

private

Definition at line 331 of file RowSetMemoryOwner.h.

Referenced by addColBuffer(), and ~RowSetMemoryOwner().

std::vector<CountDistinctBitmapBuffer> RowSetMemoryOwner::count_distinct_bitmaps_

private

Definition at line 318 of file RowSetMemoryOwner.h.

Referenced by addCountDistinctBuffer().

std::vector<CountDistinctSet*> RowSetMemoryOwner::count_distinct_sets_

private

Definition at line 319 of file RowSetMemoryOwner.h.

Referenced by addCountDistinctSet(), and ~RowSetMemoryOwner().

std::vector<int64_t*> RowSetMemoryOwner::group_by_buffers_

private

Definition at line 320 of file RowSetMemoryOwner.h.

Referenced by addGroupByBuffer(), and ~RowSetMemoryOwner().

std::shared_ptr<StringDictionaryProxy> RowSetMemoryOwner::lit_str_dict_proxy_

private

Definition at line 329 of file RowSetMemoryOwner.h.

Referenced by addLiteralStringDictProxy(), cloneStrDictDataOnly(), and getLiteralStringDictProxy().

std::mutex RowSetMemoryOwner::state_mutex_

mutableprivate

Definition at line 340 of file RowSetMemoryOwner.h.

Referenced by addArray(), addColBuffer(), addCountDistinctBuffer(), addCountDistinctSet(), addGroupByBuffer(), addLiteralStringDictProxy(), addString(), addStringDict(), addStringProxyIntersectionTranslationMap(), addStringProxyUnionTranslationMap(), addVarlenBuffer(), addVarlenInputBuffer(), allocate(), getLiteralStringDictProxy(), getStringDictProxy(), and getStringOps().

std::unordered_map<int, std::shared_ptr<StringDictionaryProxy> > RowSetMemoryOwner::str_dict_proxy_owned_

private

Definition at line 324 of file RowSetMemoryOwner.h.

Referenced by addStringDict(), cloneStrDictDataOnly(), and getStringDictProxy().

std::map<std::string, StringDictionaryProxy::IdMap> RowSetMemoryOwner::str_proxy_intersection_translation_maps_owned_

private

Definition at line 326 of file RowSetMemoryOwner.h.

Referenced by addStringProxyIntersectionTranslationMap().

std::map<std::string, StringDictionaryProxy::IdMap> RowSetMemoryOwner::str_proxy_union_translation_maps_owned_

private

Definition at line 328 of file RowSetMemoryOwner.h.

Referenced by addStringProxyUnionTranslationMap().

StringDictionaryGenerations RowSetMemoryOwner::string_dictionary_generations_

private

Definition at line 330 of file RowSetMemoryOwner.h.

Referenced by getStringDictionaryGenerations(), and setDictionaryGenerations().

std::map<std::string, std::shared_ptr<StringOps_Namespace::StringOps> > RowSetMemoryOwner::string_ops_owned_

private

Definition at line 335 of file RowSetMemoryOwner.h.

Referenced by getStringOps().

std::list<std::string> RowSetMemoryOwner::strings_

private

Definition at line 322 of file RowSetMemoryOwner.h.

Referenced by addString().

std::vector<std::unique_ptr<quantile::TDigest> > RowSetMemoryOwner::t_digests_

private

Definition at line 333 of file RowSetMemoryOwner.h.

std::map<std::string, MetadataValue> RowSetMemoryOwner::table_function_metadata_store_

private

Definition at line 343 of file RowSetMemoryOwner.h.

Referenced by getTableFunctionMetadata(), and setTableFunctionMetadata().

std::mutex RowSetMemoryOwner::table_function_metadata_store_mutex_

mutableprivate

Definition at line 344 of file RowSetMemoryOwner.h.

Referenced by getTableFunctionMetadata(), and setTableFunctionMetadata().

std::vector<void*> RowSetMemoryOwner::varlen_buffers_

private

Definition at line 321 of file RowSetMemoryOwner.h.

Referenced by addVarlenBuffer(), and ~RowSetMemoryOwner().

std::vector<Data_Namespace::AbstractBuffer*> RowSetMemoryOwner::varlen_input_buffers_

private

Definition at line 332 of file RowSetMemoryOwner.h.

Referenced by addVarlenInputBuffer(), and ~RowSetMemoryOwner().

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

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/Descriptors/RowSetMemoryOwner.h
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/Execute.cpp

Classes

Public Types

Public Member Functions

Private Types

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation