#include <heavydbTypes.h>

Collaboration diagram for TableFunctionManager:

Public Member Functions
void	set_output_array_values_total_number (int32_t index, int64_t output_array_values_total_number)

void	set_output_row_size (int64_t num_rows)

void	disable_output_allocations ()

void	enable_output_allocations ()

int32_t	error_message (const char *message)

template<typename T >
void	set_metadata (const std::string &key, const T &value)

template<typename T >
void	get_metadata (const std::string &key, T &value)

int32_t	getNewDictId ()

std::string	getString (int32_t dict_id, int32_t string_id)

const char *	getCString (int32_t dict_id, int32_t string_id)

int32_t	getOrAddTransient (int32_t dict_id, std::string str)

std::string	toString () const

	TableFunctionManager (const TableFunctionExecutionUnit &exe_unit, Executor executor, std::vector< const int8_t > &col_buf_ptrs, std::shared_ptr< RowSetMemoryOwner > row_set_mem_owner, bool is_singleton)

size_t	get_ncols () const

size_t	get_nrows () const

void	check_thread_id () const

void	set_output_column (int32_t index, int8_t *ptr)

void	set_output_array_values_total_number (int32_t index, int64_t output_array_values_total_number)

void	allocate_output_buffers (int64_t output_num_rows)

const char *	get_error_message () const

void	set_error_message (const char *msg)

void	set_metadata (const char key, const uint8_t raw_bytes, const size_t num_bytes, const TableFunctionMetadataType value_type) const

void	get_metadata (const char key, const uint8_t &raw_bytes, size_t &num_bytes, TableFunctionMetadataType &value_type) const

int32_t	getNewDictId ()

std::string	getString (int32_t dict_id, int32_t string_id)

const char *	getCString (int32_t dict_id, int32_t string_id)

const int32_t	getOrAddTransient (int32_t dict_id, const std::string &str)

bool	isSingleton () const

	~TableFunctionManager ()

Static Public Member Functions
static TableFunctionManager *	get_singleton ()

static TableFunctionManager *&	get_singleton ()

Public Attributes
bool output_allocations_disabled	false

std::unique_ptr < QueryMemoryInitializer >	query_buffers

Private Member Functions
void	lock ()

void	unlock ()

Static Private Member Functions
static void	set_singleton (TableFunctionManager *instance)

Private Attributes
const TableFunctionExecutionUnit &	exe_unit_

Executor *	executor_

std::vector< const int8_t * > &	col_buf_ptrs_

std::shared_ptr < RowSetMemoryOwner >	row_set_mem_owner_

std::vector< int64_t * >	output_col_buf_ptrs

size_t	output_num_rows_

std::vector< int64_t >	output_array_values_total_number_

std::vector< int8_t * >	output_column_ptrs

bool	is_singleton_

std::thread::id	thread_id_

std::string	error_message_

Detailed Description

Definition at line 1170 of file heavydbTypes.h.

Constructor & Destructor Documentation

TableFunctionManager::TableFunctionManager	(	const TableFunctionExecutionUnit &	exe_unit,
		Executor *	executor,
		std::vector< const int8_t * > &	col_buf_ptrs,
		std::shared_ptr< RowSetMemoryOwner >	row_set_mem_owner,
		bool	is_singleton
	)

inline

Definition at line 59 of file TableFunctionManager.h.

References get_ncols(), isSingleton(), output_array_values_total_number_, output_col_buf_ptrs, output_column_ptrs, and set_singleton().

       : exe_unit_(exe_unit)
       , executor_(executor)
       , col_buf_ptrs_(col_buf_ptrs)
       , row_set_mem_owner_(row_set_mem_owner)
       , output_num_rows_(-1)
       , is_singleton_(is_singleton)
       , thread_id_(std::this_thread::get_id()) {
     if (isSingleton()) {
       set_singleton(this);  // start of singleton life
     }
     auto num_out_columns = get_ncols();
     output_col_buf_ptrs.reserve(num_out_columns);
     output_column_ptrs.reserve(num_out_columns);
     output_array_values_total_number_.reserve(num_out_columns);
     for (size_t i = 0; i < num_out_columns; i++) {
       output_col_buf_ptrs.emplace_back(nullptr);
       output_column_ptrs.emplace_back(nullptr);
       output_array_values_total_number_.emplace_back(-1);
     }
   }

Here is the call graph for this function:

TableFunctionManager::~TableFunctionManager ( )

inline

Definition at line 261 of file TableFunctionManager.h.

References isSingleton(), and set_singleton().

                           {
     if (isSingleton()) {
       set_singleton(nullptr);  // end of singleton life
     }
   }

Here is the call graph for this function:

Member Function Documentation

void TableFunctionManager::allocate_output_buffers ( int64_t output_num_rows )

inline

Definition at line 120 of file TableFunctionManager.h.

References QueryMemoryDescriptor::addColSlotInfo(), QueryMemoryDescriptor::addColSlotInfoFlatBuffer(), align_to_int64(), CHECK, CHECK_EQ, CHECK_NE, check_thread_id(), col_buf_ptrs_, CPU, exe_unit_, executor_, get_ncols(), getVarlenArrayBufferSize(), initializeVarlenArray(), output_array_values_total_number_, output_col_buf_ptrs, output_column_ptrs, output_num_rows_, query_buffers, query_mem_desc, row_set_mem_owner_, QueryMemoryDescriptor::setOutputColumnar(), Column< T >::size(), TableFunction, TableFunctionExecutionUnit::target_exprs, and toString().

                                                         {
     check_thread_id();
     CHECK_EQ(output_num_rows_,
              size_t(-1));  // re-allocation of output buffers is not supported
 
     output_num_rows_ = output_num_rows;
     auto num_out_columns = get_ncols();
     QueryMemoryDescriptor query_mem_desc(executor_,
                                          output_num_rows,  // divide by row multiplier???
                                          QueryDescriptionType::TableFunction,
                                          /*is_table_function=*/true);
     query_mem_desc.setOutputColumnar(true);
 
     for (size_t i = 0; i < num_out_columns; i++) {
       // All outputs have padded width set to logical column width
       auto ti = exe_unit_.target_exprs[i]->get_type_info();
       if (ti.is_array()) {
         CHECK_NE(output_array_values_total_number_[i],
                  -1);  // set_output_array_values_total_number(i, ...) is not called
         /*
           Here we compute the byte size of flatbuffer and store it in
           query memory descriptor's ColSlotContext instance. The
           flatbuffer memory will be allocated in
           QueryMemoryInitializer constructor and the memory will be
           initialized below.
          */
         const int64_t flatbuffer_size = getVarlenArrayBufferSize(
             output_num_rows_, output_array_values_total_number_[i], ti);
         query_mem_desc.addColSlotInfoFlatBuffer(
             flatbuffer_size);  // used by QueryMemoryInitializer
       } else {
         const size_t col_width = ti.get_size();
         query_mem_desc.addColSlotInfo({std::make_tuple(col_width, col_width)});
       }
     }
 
     // The members layout of Column must match with Column defined in
     // heavydbTypes.h
     struct Column {
       int8_t* ptr;
       int64_t size;
       // just for debugging:
       std::string toString() const {
         return "Column{" + ::toString(ptr) + ", " + ::toString(size) + "}";
       }
     };
     // We do not init output buffers for CPU currently, so CPU
     // table functions are expected to handle their own initialization
     query_buffers = std::make_unique<QueryMemoryInitializer>(
         exe_unit_,
         query_mem_desc,
         /*device_id=*/0,
         ExecutorDeviceType::CPU,
         (output_num_rows_ == 0 ? 1 : output_num_rows_),
         std::vector<std::vector<const int8_t*>>{col_buf_ptrs_},
         std::vector<std::vector<uint64_t>>{{0}},  // frag offsets
         row_set_mem_owner_,
         nullptr,
         executor_);
     if (output_num_rows_ != 0) {
       auto group_by_buffers_ptr = query_buffers->getGroupByBuffersPtr();
       CHECK(group_by_buffers_ptr);
       auto output_buffers_ptr = reinterpret_cast<int8_t*>(group_by_buffers_ptr[0]);
       for (size_t i = 0; i < num_out_columns; i++) {
         Column* col = reinterpret_cast<Column*>(output_column_ptrs[i]);
         CHECK(col);
         // set the members of output Column instances:
         output_col_buf_ptrs[i] = reinterpret_cast<int64_t*>(output_buffers_ptr);
         col->ptr = output_buffers_ptr;
         col->size = output_num_rows_;
 
         auto ti = exe_unit_.target_exprs[i]->get_type_info();
         if (ti.is_array()) {
           FlatBufferManager m{output_buffers_ptr};
           initializeVarlenArray(
               m, output_num_rows_, output_array_values_total_number_[i], ti);
           output_buffers_ptr = align_to_int64(output_buffers_ptr + m.flatbufferSize());
         } else {
           const size_t col_width = ti.get_size();
           output_buffers_ptr =
               align_to_int64(output_buffers_ptr + col_width * output_num_rows_);
         }
       }
     }
   }

Here is the call graph for this function:

void TableFunctionManager::check_thread_id ( ) const

inline

Definition at line 91 of file TableFunctionManager.h.

References thread_id_.

Referenced by allocate_output_buffers(), get_error_message(), set_error_message(), and set_output_column().

                                {
     if (std::this_thread::get_id() != thread_id_) {
       throw std::runtime_error(
           "TableFunctionManager instance accessed from an alien thread!");
     }
   }

Here is the caller graph for this function:

void TableFunctionManager::disable_output_allocations ( )

inline

Definition at line 1187 of file heavydbTypes.h.

Referenced by linear_reg_fit_predict__cpu_template().

1187 { output_allocations_disabled = true; }

Here is the caller graph for this function:

void TableFunctionManager::enable_output_allocations ( )

inline

Definition at line 1189 of file heavydbTypes.h.

Referenced by linear_reg_fit_predict__cpu_template().

1189 { output_allocations_disabled = false; }

Here is the caller graph for this function:

int32_t TableFunctionManager::error_message ( const char * message )

inline

Definition at line 1191 of file heavydbTypes.h.

References TableFunctionManager_error_message().

                                              {
     return TableFunctionManager_error_message(reinterpret_cast<int8_t*>(this), message);
   }

Here is the call graph for this function:

const char* TableFunctionManager::get_error_message ( ) const

inline

Definition at line 206 of file TableFunctionManager.h.

References check_thread_id(), and error_message_.

                                         {
     check_thread_id();
     return error_message_.c_str();
   }

Here is the call graph for this function:

void TableFunctionManager::get_metadata	(	const char *	key,
		const uint8_t *&	raw_bytes,
		size_t &	num_bytes,
		TableFunctionMetadataType &	value_type
	)		const

inline

Definition at line 224 of file TableFunctionManager.h.

References CHECK, and row_set_mem_owner_.

                                                                  {
     CHECK(row_set_mem_owner_);
     row_set_mem_owner_->getTableFunctionMetadata(key, raw_bytes, num_bytes, value_type);
   }

template<typename T >

void TableFunctionManager::get_metadata	(	const std::string &	key,
		T &	value
	)

inline

Definition at line 1205 of file heavydbTypes.h.

References heavydb.dtypes::T, and TableFunctionManager_get_metadata().

Referenced by tf_metadata_getter__cpu_template(), and tf_metadata_getter_bad__cpu_template().

                                                     {
     const uint8_t* raw_data{};
     size_t num_bytes{};
     TableFunctionMetadataType value_type;
     TableFunctionManager_get_metadata(
         reinterpret_cast<int8_t*>(this), key.c_str(), raw_data, num_bytes, value_type);
     if (sizeof(T) != num_bytes) {
       throw std::runtime_error("Size mismatch for Table Function Metadata '" + key + "'");
     }
     if (get_metadata_type<T>() != value_type) {
       throw std::runtime_error("Type mismatch for Table Function Metadata '" + key + "'");
     }
     std::memcpy(&value, raw_data, num_bytes);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t TableFunctionManager::get_ncols ( ) const

inline

Definition at line 86 of file TableFunctionManager.h.

References exe_unit_, and TableFunctionExecutionUnit::target_exprs.

Referenced by allocate_output_buffers(), set_output_array_values_total_number(), set_output_column(), and TableFunctionManager().

86 { return exe_unit_.target_exprs.size(); }

TableFunctionManager::exe_unit_

const TableFunctionExecutionUnit & exe_unit_

Definition: TableFunctionManager.h:289

TableFunctionExecutionUnit::target_exprs

std::vector< Analyzer::Expr * > target_exprs

Definition: RelAlgExecutionUnit.h:166

Here is the caller graph for this function:

size_t TableFunctionManager::get_nrows ( ) const

inline

Definition at line 89 of file TableFunctionManager.h.

References output_num_rows_.

89 { return output_num_rows_; }

TableFunctionManager::output_num_rows_

size_t output_num_rows_

Definition: TableFunctionManager.h:298

static TableFunctionManager*& TableFunctionManager::get_singleton ( )

inlinestatic

Definition at line 267 of file TableFunctionManager.h.

                                                 {
     static TableFunctionManager* instance = nullptr;
     return instance;
   }

static TableFunctionManager* TableFunctionManager::get_singleton ( )

inlinestatic

Definition at line 1171 of file heavydbTypes.h.

References TableFunctionManager_get_singleton().

Referenced by ct_sleep1__cpu_(), ct_sleep2(), set_singleton(), and sum_along_row__cpu_template().

                                                {
     return reinterpret_cast<TableFunctionManager*>(TableFunctionManager_get_singleton());
   }

Here is the call graph for this function:

Here is the caller graph for this function:

const char* TableFunctionManager::getCString	(	int32_t	dict_id,
		int32_t	string_id
	)

inline

Definition at line 244 of file TableFunctionManager.h.

References executor_, and row_set_mem_owner_.

                                                                     {
     const auto proxy =
         executor_->getStringDictionaryProxy(dict_id, row_set_mem_owner_, true);
     auto [c_str, len] = proxy->getStringBytes(string_id);
     return c_str;
   }

const char* TableFunctionManager::getCString	(	int32_t	dict_id,
		int32_t	string_id
	)

inline

Definition at line 1226 of file heavydbTypes.h.

References TableFunctionManager_getCString().

                                                              {
     return TableFunctionManager_getCString(
         reinterpret_cast<int8_t*>(this), dict_id, string_id);
   }

Here is the call graph for this function:

int32_t TableFunctionManager::getNewDictId ( )

inline

Definition at line 232 of file TableFunctionManager.h.

References executor_, row_set_mem_owner_, and TRANSIENT_DICT_ID.

                                 {
     const auto proxy =
         executor_->getStringDictionaryProxy(TRANSIENT_DICT_ID, row_set_mem_owner_, true);
     return proxy->getDictId();
   }

int32_t TableFunctionManager::getNewDictId ( )

inline

Definition at line 1219 of file heavydbTypes.h.

References TableFunctionManager_getNewDictId().

Referenced by array_asarray__cpu_template().

                          {
     return TableFunctionManager_getNewDictId(reinterpret_cast<int8_t*>(this));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

const int32_t TableFunctionManager::getOrAddTransient	(	int32_t	dict_id,
		const std::string &	str
	)

inline

Definition at line 251 of file TableFunctionManager.h.

References executor_, and row_set_mem_owner_.

                                                                                 {
     const auto proxy =
         executor_->getStringDictionaryProxy(dict_id, row_set_mem_owner_, true);
     return proxy->getOrAddTransient(str);
   }

int32_t TableFunctionManager::getOrAddTransient	(	int32_t	dict_id,
		std::string	str
	)

inline

Definition at line 1230 of file heavydbTypes.h.

References TableFunctionManager_getOrAddTransient().

Referenced by array_asarray__cpu_template().

                                                             {
     return TableFunctionManager_getOrAddTransient(
         reinterpret_cast<int8_t*>(this), dict_id, str);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string TableFunctionManager::getString	(	int32_t	dict_id,
		int32_t	string_id
	)

inline

Definition at line 238 of file TableFunctionManager.h.

References executor_, and row_set_mem_owner_.

                                                                  {
     const auto proxy =
         executor_->getStringDictionaryProxy(dict_id, row_set_mem_owner_, true);
     return proxy->getString(string_id);
   }

std::string TableFunctionManager::getString	(	int32_t	dict_id,
		int32_t	string_id
	)

inline

Definition at line 1222 of file heavydbTypes.h.

References TableFunctionManager_getString().

Referenced by array_asarray__cpu_template().

                                                           {
     return TableFunctionManager_getString(
         reinterpret_cast<int8_t*>(this), dict_id, string_id);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

bool TableFunctionManager::isSingleton ( ) const

inline

Definition at line 259 of file TableFunctionManager.h.

References is_singleton_.

Referenced by TableFunctionManager(), and ~TableFunctionManager().

259 { return is_singleton_; }

TableFunctionManager::is_singleton_

bool is_singleton_

Definition: TableFunctionManager.h:304

Here is the caller graph for this function:

void TableFunctionManager::lock ( )

inlineprivate

Definition at line 273 of file TableFunctionManager.h.

References TableFunctionManager_singleton_mutex.

Referenced by set_singleton().

273 { TableFunctionManager_singleton_mutex.lock(); }

TableFunctionManager_singleton_mutex

std::mutex TableFunctionManager_singleton_mutex

Definition: TableFunctionExecutionContext.cpp:348

Here is the caller graph for this function:

void TableFunctionManager::set_error_message ( const char * msg )

inline

Definition at line 211 of file TableFunctionManager.h.

References check_thread_id(), and error_message_.

                                           {
     check_thread_id();
     error_message_ = std::string(msg);
   }

Here is the call graph for this function:

void TableFunctionManager::set_metadata	(	const char *	key,
		const uint8_t *	raw_bytes,
		const size_t	num_bytes,
		const TableFunctionMetadataType	value_type
	)		const

inline

Definition at line 216 of file TableFunctionManager.h.

References CHECK, and row_set_mem_owner_.

                                                                       {
     CHECK(row_set_mem_owner_);
     row_set_mem_owner_->setTableFunctionMetadata(key, raw_bytes, num_bytes, value_type);
   }

template<typename T >

void TableFunctionManager::set_metadata	(	const std::string &	key,
		const T &	value
	)

inline

Definition at line 1196 of file heavydbTypes.h.

References TableFunctionManager_set_metadata().

Referenced by GeoRaster< T, Z >::setMetadata(), tf_metadata_setter__cpu_template(), tf_metadata_setter_repeated__cpu_template(), and tf_metadata_setter_size_mismatch__cpu_template().

                                                           {
     TableFunctionManager_set_metadata(reinterpret_cast<int8_t*>(this),
                                       key.c_str(),
                                       reinterpret_cast<const uint8_t*>(&value),
                                       sizeof(value),
                                       get_metadata_type<T>());
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void TableFunctionManager::set_output_array_values_total_number	(	int32_t	index,
		int64_t	output_array_values_total_number
	)

inline

Definition at line 107 of file TableFunctionManager.h.

References CHECK_EQ, CHECK_LE, CHECK_LT, get_ncols(), output_array_values_total_number_, and output_num_rows_.

                                                                                       {
     CHECK_EQ(output_num_rows_,
              size_t(-1));  // set_output_array_size must be called
                            // before set_output_row_size because
                            // set_output_row_size allocates the output
                            // buffers
     int32_t num_out_columns = get_ncols();
     CHECK_LE(0, index);
     CHECK_LT(index, num_out_columns);
     output_array_values_total_number_[index] = output_array_values_total_number;
   }

Here is the call graph for this function:

void TableFunctionManager::set_output_array_values_total_number	(	int32_t	index,
		int64_t	output_array_values_total_number
	)

inline

Definition at line 1175 of file heavydbTypes.h.

References TableFunctionManager_set_output_array_values_total_number().

Referenced by array_asarray__cpu_template(), array_concat__cpu_template(), array_copier__cpu_template(), and array_split__cpu_template().

                                                                                       {
     TableFunctionManager_set_output_array_values_total_number(
         reinterpret_cast<int8_t*>(this), index, output_array_values_total_number);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void TableFunctionManager::set_output_column	(	int32_t	index,
		int8_t *	ptr
	)

inline

Definition at line 99 of file TableFunctionManager.h.

References CHECK, check_thread_id(), get_ncols(), and output_column_ptrs.

                                                      {
     check_thread_id();
     CHECK(index >= 0 && index < static_cast<int32_t>(get_ncols()));
     CHECK(ptr);
     output_column_ptrs[index] = ptr;
   }

Here is the call graph for this function:

void TableFunctionManager::set_output_row_size ( int64_t num_rows )

inline

Definition at line 1181 of file heavydbTypes.h.

References TableFunctionManager_set_output_row_size().

Referenced by array_asarray__cpu_template(), array_concat__cpu_template(), array_copier__cpu_template(), array_split__cpu_template(), ct_add_size_and_mul_alpha(), ct_copy_and_add_size(), ct_cursor_named_args__cpu_(), ct_pushdown_projection__cpu_template(), ct_pushdown_stats__cpu_template(), ct_scalar_named_args__cpu_(), ct_sleep2(), ct_sparse_add(), ct_string_concat__cpu_(), ct_substr__cpu_(), ct_synthesize_new_dict__cpu_(), ct_test_preflight_multicursor_qe227__cpu_(), ct_test_preflight_singlecursor_qe227__cpu_(), ct_throw_if_gt_100__cpu_template(), ct_timestamp_add_interval__template(), ct_timestamp_add_offset(), ct_timestamp_column_list_input(), ct_timestamp_extract(), ct_timestamp_truncate(), ct_union_pushdown_projection__cpu_template(), ct_union_pushdown_stats__cpu_template(), dbscan__cpu_template(), generate_random_strings__cpu_(), generate_series__cpu_template(), kmeans__cpu_template(), linear_reg_fit__cpu_template(), linear_reg_predict__cpu_template(), Mandelbrot::mandelbrot_cpu_template(), GeoRaster< T, Z >::outputDenseColumns(), supported_ml_frameworks__cpu_(), tf_metadata_getter__cpu_template(), tf_metadata_getter_bad__cpu_template(), tf_metadata_setter__cpu_template(), tf_metadata_setter_repeated__cpu_template(), and tf_metadata_setter_size_mismatch__cpu_template().

                                              {
     if (!output_allocations_disabled) {
       TableFunctionManager_set_output_row_size(reinterpret_cast<int8_t*>(this), num_rows);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

static void TableFunctionManager::set_singleton ( TableFunctionManager * instance )

inlinestaticprivate

Definition at line 276 of file TableFunctionManager.h.

References CHECK, get_singleton(), and lock().

Referenced by TableFunctionManager(), and ~TableFunctionManager().

                                                             {
     auto& instance_ = get_singleton();
     // ensure being singleton and lock/unlock
     if (instance) {
       instance->lock();
       CHECK(instance_ == nullptr);
     } else {
       CHECK(instance_ != nullptr);
       instance_->unlock();
     }
     instance_ = instance;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string TableFunctionManager::toString ( ) const

inline

Definition at line 1236 of file heavydbTypes.h.

References run_benchmark_import::result, and typeName().

Referenced by allocate_output_buffers().

                              {
     std::string result = ::typeName(this) + "(";
     if (!(void*)this) {  // cast to void* to avoid warnings
       result += "UNINITIALIZED";
     }
     result += ")";
     return result;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void TableFunctionManager::unlock ( )

inlineprivate

Definition at line 274 of file TableFunctionManager.h.

References TableFunctionManager_singleton_mutex.

274 { TableFunctionManager_singleton_mutex.unlock(); }

TableFunctionManager_singleton_mutex

std::mutex TableFunctionManager_singleton_mutex

Definition: TableFunctionExecutionContext.cpp:348

Member Data Documentation

std::vector<const int8_t*>& TableFunctionManager::col_buf_ptrs_

private

Definition at line 292 of file TableFunctionManager.h.

Referenced by allocate_output_buffers().

std::string TableFunctionManager::error_message_

private

Definition at line 308 of file TableFunctionManager.h.

Referenced by get_error_message(), and set_error_message().

const TableFunctionExecutionUnit& TableFunctionManager::exe_unit_

private

Definition at line 289 of file TableFunctionManager.h.

Referenced by allocate_output_buffers(), and get_ncols().

Executor* TableFunctionManager::executor_

private

Definition at line 290 of file TableFunctionManager.h.

Referenced by allocate_output_buffers(), getCString(), getNewDictId(), getOrAddTransient(), and getString().

bool output_allocations_disabled TableFunctionManager::false

Definition at line 1245 of file heavydbTypes.h.

bool TableFunctionManager::is_singleton_

private

Definition at line 304 of file TableFunctionManager.h.

Referenced by isSingleton().

std::vector<int64_t> TableFunctionManager::output_array_values_total_number_

private

Definition at line 300 of file TableFunctionManager.h.

Referenced by allocate_output_buffers(), set_output_array_values_total_number(), and TableFunctionManager().

std::vector<int64_t*> TableFunctionManager::output_col_buf_ptrs

private

Definition at line 296 of file TableFunctionManager.h.

Referenced by allocate_output_buffers(), and TableFunctionManager().

std::vector<int8_t*> TableFunctionManager::output_column_ptrs

private

Definition at line 302 of file TableFunctionManager.h.

Referenced by allocate_output_buffers(), set_output_column(), and TableFunctionManager().

size_t TableFunctionManager::output_num_rows_

private

Definition at line 298 of file TableFunctionManager.h.

Referenced by allocate_output_buffers(), get_nrows(), and set_output_array_values_total_number().

std::unique_ptr<QueryMemoryInitializer> TableFunctionManager::query_buffers

Definition at line 57 of file TableFunctionManager.h.

Referenced by allocate_output_buffers().

std::shared_ptr<RowSetMemoryOwner> TableFunctionManager::row_set_mem_owner_

private

Definition at line 294 of file TableFunctionManager.h.

Referenced by allocate_output_buffers(), get_metadata(), getCString(), getNewDictId(), getOrAddTransient(), getString(), and set_metadata().

std::thread::id TableFunctionManager::thread_id_

private

Definition at line 306 of file TableFunctionManager.h.

Referenced by check_thread_id().

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

/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/heavydbTypes.h
/home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/TableFunctions/TableFunctionManager.h

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation