#include <Importer.h>

Inheritance diagram for import_export::Loader:

Collaboration diagram for import_export::Loader:

Public Member Functions
	Loader (Catalog_Namespace::Catalog &c, const TableDescriptor *t, LoadCallbackType load_callback=nullptr)

virtual	~Loader ()

Catalog_Namespace::Catalog &	getCatalog () const

const TableDescriptor *	getTableDesc () const

const std::list< const ColumnDescriptor * > &	get_column_descs () const

StringDictionary *	getStringDict (const ColumnDescriptor *cd) const

virtual bool	load (const std::vector< std::unique_ptr< TypedImportBuffer >> &import_buffers, const size_t row_count, const Catalog_Namespace::SessionInfo *session_info)

virtual bool	loadNoCheckpoint (const std::vector< std::unique_ptr< TypedImportBuffer >> &import_buffers, const size_t row_count, const Catalog_Namespace::SessionInfo *session_info)

virtual void	checkpoint ()

virtual std::vector < Catalog_Namespace::TableEpochInfo >	getTableEpochs () const

virtual void	setTableEpochs (const std::vector< Catalog_Namespace::TableEpochInfo > &table_epochs)

void	setAddingColumns (const bool adding_columns)

bool	isAddingColumns () const

void	dropColumns (const std::vector< int > &columns)

std::string	getErrorMessage ()

Protected Types
using	OneShardBuffers = std::vector< std::unique_ptr< TypedImportBuffer >>

Protected Member Functions
void	init ()

virtual bool	loadImpl (const std::vector< std::unique_ptr< TypedImportBuffer >> &import_buffers, size_t row_count, bool checkpoint, const Catalog_Namespace::SessionInfo *session_info)

void	distributeToShards (std::vector< OneShardBuffers > &all_shard_import_buffers, std::vector< size_t > &all_shard_row_counts, const OneShardBuffers &import_buffers, const size_t row_count, const size_t shard_count, const Catalog_Namespace::SessionInfo *session_info)

Protected Attributes
Catalog_Namespace::Catalog &	catalog_

const TableDescriptor *	table_desc_

std::list< const ColumnDescriptor * >	column_descs_

LoadCallbackType	load_callback_

Fragmenter_Namespace::InsertData	insert_data_

std::map< int, StringDictionary * >	dict_map_

Private Types
using	LoadCallbackType = std::function< bool(const std::vector< std::unique_ptr< TypedImportBuffer >> &, std::vector< DataBlockPtr > &, size_t)>

Private Member Functions
bool	loadToShard (const std::vector< std::unique_ptr< TypedImportBuffer >> &import_buffers, size_t row_count, const TableDescriptor shard_table, bool checkpoint, const Catalog_Namespace::SessionInfo session_info)

void	distributeToShardsNewColumns (std::vector< OneShardBuffers > &all_shard_import_buffers, std::vector< size_t > &all_shard_row_counts, const OneShardBuffers &import_buffers, const size_t row_count, const size_t shard_count, const Catalog_Namespace::SessionInfo *session_info)

void	distributeToShardsExistingColumns (std::vector< OneShardBuffers > &all_shard_import_buffers, std::vector< size_t > &all_shard_row_counts, const OneShardBuffers &import_buffers, const size_t row_count, const size_t shard_count, const Catalog_Namespace::SessionInfo *session_info)

void	fillShardRow (const size_t row_index, OneShardBuffers &shard_output_buffers, const OneShardBuffers &import_buffers)

Private Attributes
bool	adding_columns_ = false

std::mutex	loader_mutex_

std::string	error_msg_

Detailed Description

Definition at line 551 of file Importer.h.

Member Typedef Documentation

using import_export::Loader::LoadCallbackType = std::function<bool(const std::vector<std::unique_ptr<TypedImportBuffer>>&, std::vector<DataBlockPtr>&, size_t)>

private

Definition at line 555 of file Importer.h.

using import_export::Loader::OneShardBuffers = std::vector<std::unique_ptr<TypedImportBuffer>>

protected

Definition at line 613 of file Importer.h.

Constructor & Destructor Documentation

import_export::Loader::Loader	(	Catalog_Namespace::Catalog &	c,
		const TableDescriptor *	t,
		LoadCallbackType	load_callback = `nullptr`
	)

inline

Definition at line 559 of file Importer.h.

References init().

       : catalog_(c)
       , table_desc_(t)
       , column_descs_(c.getAllColumnMetadataForTable(t->tableId, false, false, true))
       , load_callback_(load_callback) {
     init();
   }

Here is the call graph for this function:

virtual import_export::Loader::~Loader ( )

inlinevirtual

Definition at line 569 of file Importer.h.

569 {}

Member Function Documentation

void import_export::Loader::checkpoint ( )

virtual

Definition at line 4666 of file Importer.cpp.

References Catalog_Namespace::Catalog::checkpointWithAutoRollback(), Data_Namespace::DISK_LEVEL, getCatalog(), and getTableDesc().

                         {
   if (getTableDesc()->persistenceLevel ==
       Data_Namespace::MemoryLevel::DISK_LEVEL) {  // only checkpoint disk-resident
                                                   // tables
     getCatalog().checkpointWithAutoRollback(getTableDesc()->tableId);
   }
 }

Here is the call graph for this function:

void import_export::Loader::distributeToShards	(	std::vector< OneShardBuffers > &	all_shard_import_buffers,
		std::vector< size_t > &	all_shard_row_counts,
		const OneShardBuffers &	import_buffers,
		const size_t	row_count,
		const size_t	shard_count,
		const Catalog_Namespace::SessionInfo *	session_info
	)

protected

Definition at line 2949 of file Importer.cpp.

References CHECK_GT, distributeToShardsExistingColumns(), distributeToShardsNewColumns(), isAddingColumns(), TableDescriptor::shardedColumnId, and table_desc_.

Referenced by loadImpl().

                                                                                   {
   all_shard_row_counts.resize(shard_count);
   for (size_t shard_idx = 0; shard_idx < shard_count; ++shard_idx) {
     all_shard_import_buffers.emplace_back();
     for (const auto& typed_import_buffer : import_buffers) {
       all_shard_import_buffers.back().emplace_back(
           new TypedImportBuffer(typed_import_buffer->getColumnDesc(),
                                 typed_import_buffer->getStringDictionary()));
     }
   }
   CHECK_GT(table_desc_->shardedColumnId, 0);
   if (isAddingColumns()) {
     distributeToShardsNewColumns(all_shard_import_buffers,
                                  all_shard_row_counts,
                                  import_buffers,
                                  row_count,
                                  shard_count,
                                  session_info);
   } else {
     distributeToShardsExistingColumns(all_shard_import_buffers,
                                       all_shard_row_counts,
                                       import_buffers,
                                       row_count,
                                       shard_count,
                                       session_info);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void import_export::Loader::distributeToShardsExistingColumns	(	std::vector< OneShardBuffers > &	all_shard_import_buffers,
		std::vector< size_t > &	all_shard_row_counts,
		const OneShardBuffers &	import_buffers,
		const size_t	row_count,
		const size_t	shard_count,
		const Catalog_Namespace::SessionInfo *	session_info
	)

private

Definition at line 2890 of file Importer.cpp.

References CHECK, CHECK_LE, column_descs_, fillShardRow(), import_export::anonymous_namespace{Importer.cpp}::int_value_at(), kENCODING_DICT, SHARD_FOR_KEY, TableDescriptor::shardedColumnId, and table_desc_.

Referenced by distributeToShards().

                                                       {
   int col_idx{0};
   const ColumnDescriptor* shard_col_desc{nullptr};
   for (const auto col_desc : column_descs_) {
     ++col_idx;
     if (col_idx == table_desc_->shardedColumnId) {
       shard_col_desc = col_desc;
       break;
     }
   }
   CHECK(shard_col_desc);
   CHECK_LE(static_cast<size_t>(table_desc_->shardedColumnId), import_buffers.size());
   auto& shard_column_input_buffer = import_buffers[table_desc_->shardedColumnId - 1];
   const auto& shard_col_ti = shard_col_desc->columnType;
   CHECK(shard_col_ti.is_integer() ||
         (shard_col_ti.is_string() && shard_col_ti.get_compression() == kENCODING_DICT) ||
         shard_col_ti.is_time());
   if (shard_col_ti.is_string()) {
     const auto payloads_ptr = shard_column_input_buffer->getStringBuffer();
     CHECK(payloads_ptr);
     shard_column_input_buffer->addDictEncodedString(*payloads_ptr);
   }
 
   for (size_t i = 0; i < row_count; ++i) {
     const size_t shard =
         SHARD_FOR_KEY(int_value_at(*shard_column_input_buffer, i), shard_count);
     auto& shard_output_buffers = all_shard_import_buffers[shard];
     fillShardRow(i, shard_output_buffers, import_buffers);
     ++all_shard_row_counts[shard];
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void import_export::Loader::distributeToShardsNewColumns	(	std::vector< OneShardBuffers > &	all_shard_import_buffers,
		std::vector< size_t > &	all_shard_row_counts,
		const OneShardBuffers &	import_buffers,
		const size_t	row_count,
		const size_t	shard_count,
		const Catalog_Namespace::SessionInfo *	session_info
	)

private

Definition at line 2928 of file Importer.cpp.

References catalog_, CHECK, fillShardRow(), Catalog_Namespace::Catalog::getPhysicalTablesDescriptors(), and table_desc_.

Referenced by distributeToShards().

                                                       {
   const auto shard_tds = catalog_.getPhysicalTablesDescriptors(table_desc_);
   CHECK(shard_tds.size() == shard_count);
 
   for (size_t shard = 0; shard < shard_count; ++shard) {
     auto& shard_output_buffers = all_shard_import_buffers[shard];
     if (row_count != 0) {
       fillShardRow(0, shard_output_buffers, import_buffers);
     }
     // when replicating a column, row count of a shard == replicate count of the column
     // on the shard
     all_shard_row_counts[shard] = shard_tds[shard]->fragmenter->getNumRows();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void import_export::Loader::dropColumns ( const std::vector< int > & columns )

Definition at line 3132 of file Importer.cpp.

References catalog_, Catalog_Namespace::Catalog::getPhysicalTablesDescriptors(), TableDescriptor::nShards, and table_desc_.

                                                         {
   std::vector<const TableDescriptor*> table_descs(1, table_desc_);
   if (table_desc_->nShards) {
     table_descs = catalog_.getPhysicalTablesDescriptors(table_desc_);
   }
   for (auto table_desc : table_descs) {
     table_desc->fragmenter->dropColumns(columnIds);
   }
 }

Here is the call graph for this function:

void import_export::Loader::fillShardRow	(	const size_t	row_index,
		OneShardBuffers &	shard_output_buffers,
		const OneShardBuffers &	import_buffers
	)

private

Definition at line 2816 of file Importer.cpp.

References CHECK, CHECK_LT, decimal_to_int_type(), import_export::anonymous_namespace{Importer.cpp}::double_value_at(), import_export::anonymous_namespace{Importer.cpp}::float_value_at(), import_export::anonymous_namespace{Importer.cpp}::int_value_at(), IS_STRING, kARRAY, kBIGINT, kBOOLEAN, kCHAR, kDATE, kDOUBLE, kFLOAT, kINT, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, and run_benchmark_import::type.

Referenced by distributeToShardsExistingColumns(), and distributeToShardsNewColumns().

                                                                  {
   for (size_t col_idx = 0; col_idx < import_buffers.size(); ++col_idx) {
     const auto& input_buffer = import_buffers[col_idx];
     const auto& col_ti = input_buffer->getTypeInfo();
     const auto type =
         col_ti.is_decimal() ? decimal_to_int_type(col_ti) : col_ti.get_type();
 
     switch (type) {
       case kBOOLEAN:
         shard_output_buffers[col_idx]->addBoolean(int_value_at(*input_buffer, row_index));
         break;
       case kTINYINT:
         shard_output_buffers[col_idx]->addTinyint(int_value_at(*input_buffer, row_index));
         break;
       case kSMALLINT:
         shard_output_buffers[col_idx]->addSmallint(
             int_value_at(*input_buffer, row_index));
         break;
       case kINT:
         shard_output_buffers[col_idx]->addInt(int_value_at(*input_buffer, row_index));
         break;
       case kBIGINT:
         shard_output_buffers[col_idx]->addBigint(int_value_at(*input_buffer, row_index));
         break;
       case kFLOAT:
         shard_output_buffers[col_idx]->addFloat(float_value_at(*input_buffer, row_index));
         break;
       case kDOUBLE:
         shard_output_buffers[col_idx]->addDouble(
             double_value_at(*input_buffer, row_index));
         break;
       case kTEXT:
       case kVARCHAR:
       case kCHAR: {
         CHECK_LT(row_index, input_buffer->getStringBuffer()->size());
         shard_output_buffers[col_idx]->addString(
             (*input_buffer->getStringBuffer())[row_index]);
         break;
       }
       case kTIME:
       case kTIMESTAMP:
       case kDATE:
         shard_output_buffers[col_idx]->addBigint(int_value_at(*input_buffer, row_index));
         break;
       case kARRAY:
         if (IS_STRING(col_ti.get_subtype())) {
           CHECK(input_buffer->getStringArrayBuffer());
           CHECK_LT(row_index, input_buffer->getStringArrayBuffer()->size());
           const auto& input_arr = (*(input_buffer->getStringArrayBuffer()))[row_index];
           shard_output_buffers[col_idx]->addStringArray(input_arr);
         } else {
           shard_output_buffers[col_idx]->addArray(
               (*input_buffer->getArrayBuffer())[row_index]);
         }
         break;
       case kPOINT:
       case kMULTIPOINT:
       case kLINESTRING:
       case kMULTILINESTRING:
       case kPOLYGON:
       case kMULTIPOLYGON: {
         CHECK_LT(row_index, input_buffer->getGeoStringBuffer()->size());
         shard_output_buffers[col_idx]->addGeoString(
             (*input_buffer->getGeoStringBuffer())[row_index]);
         break;
       }
       default:
         CHECK(false);
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const std::list<const ColumnDescriptor*>& import_export::Loader::get_column_descs ( ) const

inline

Definition at line 573 of file Importer.h.

References column_descs_.

Referenced by import_export::setup_column_loaders().

                                                                    {
     return column_descs_;
   }

Here is the caller graph for this function:

Catalog_Namespace::Catalog& import_export::Loader::getCatalog ( ) const

inline

Definition at line 571 of file Importer.h.

References catalog_.

Referenced by checkpoint(), getTableEpochs(), and setTableEpochs().

571 { return catalog_; }

import_export::Loader::catalog_

Catalog_Namespace::Catalog & catalog_

Definition: Importer.h:621

Here is the caller graph for this function:

std::string import_export::Loader::getErrorMessage ( )

inline

Definition at line 602 of file Importer.h.

References error_msg_.

602 { return error_msg_; };

import_export::Loader::error_msg_

std::string error_msg_

Definition: Importer.h:654

StringDictionary* import_export::Loader::getStringDict ( const ColumnDescriptor * cd ) const

inline

Definition at line 577 of file Importer.h.

References ColumnDescriptor::columnId, ColumnDescriptor::columnType, dict_map_, SQLTypeInfo::get_compression(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), IS_STRING, SQLTypeInfo::is_string(), kARRAY, and kENCODING_DICT.

Referenced by import_export::setup_column_loaders().

                                                                     {
     if ((cd->columnType.get_type() != kARRAY ||
          !IS_STRING(cd->columnType.get_subtype())) &&
         (!cd->columnType.is_string() ||
          cd->columnType.get_compression() != kENCODING_DICT)) {
       return nullptr;
     }
     return dict_map_.at(cd->columnId);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

const TableDescriptor* import_export::Loader::getTableDesc ( ) const

inline

Definition at line 572 of file Importer.h.

References table_desc_.

Referenced by checkpoint(), and getTableEpochs().

572 { return table_desc_; }

import_export::Loader::table_desc_

const TableDescriptor * table_desc_

Definition: Importer.h:622

Here is the caller graph for this function:

std::vector< Catalog_Namespace::TableEpochInfo > import_export::Loader::getTableEpochs ( ) const

virtual

Definition at line 4674 of file Importer.cpp.

References getCatalog(), getTableDesc(), and Catalog_Namespace::Catalog::getTableEpochs().

                                                                         {
   return getCatalog().getTableEpochs(getCatalog().getCurrentDB().dbId,
                                      getTableDesc()->tableId);
 }

Here is the call graph for this function:

void import_export::Loader::init ( )

protected

Definition at line 3142 of file Importer.cpp.

References catalog_, CHECK, column_descs_, Fragmenter_Namespace::InsertData::columnIds, Fragmenter_Namespace::InsertData::databaseId, Catalog_Namespace::DBMetadata::dbId, dict_map_, Catalog_Namespace::Catalog::getCurrentDB(), Catalog_Namespace::Catalog::getMetadataForDict(), insert_data_, kENCODING_DICT, Fragmenter_Namespace::InsertData::numRows, table_desc_, TableDescriptor::tableId, and Fragmenter_Namespace::InsertData::tableId.

Referenced by Loader().

                   {
   insert_data_.databaseId = catalog_.getCurrentDB().dbId;
   insert_data_.tableId = table_desc_->tableId;
   for (auto cd : column_descs_) {
     insert_data_.columnIds.push_back(cd->columnId);
     if (cd->columnType.get_compression() == kENCODING_DICT) {
       CHECK(cd->columnType.is_string() || cd->columnType.is_string_array());
       const auto dd = catalog_.getMetadataForDict(cd->columnType.get_comp_param());
       CHECK(dd);
       dict_map_[cd->columnId] = dd->stringDict.get();
     }
   }
   insert_data_.numRows = 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool import_export::Loader::isAddingColumns ( ) const

inline

Definition at line 600 of file Importer.h.

References adding_columns_.

Referenced by distributeToShards(), and loadToShard().

600 { return adding_columns_; }

import_export::Loader::adding_columns_

bool adding_columns_

Definition: Importer.h:652

Here is the caller graph for this function:

bool import_export::Loader::load	(	const std::vector< std::unique_ptr< TypedImportBuffer >> &	import_buffers,
		const size_t	row_count,
		const Catalog_Namespace::SessionInfo *	session_info
	)

virtual

Reimplemented in DistributedLoader.

Definition at line 2761 of file Importer.cpp.

References loadImpl().

                                                                     {
   return loadImpl(import_buffers, row_count, true, session_info);
 }

Here is the call graph for this function:

bool import_export::Loader::loadImpl	(	const std::vector< std::unique_ptr< TypedImportBuffer >> &	import_buffers,
		size_t	row_count,
		bool	checkpoint,
		const Catalog_Namespace::SessionInfo *	session_info
	)

protectedvirtual

Definition at line 2982 of file Importer.cpp.

References catalog_, distributeToShards(), import_export::TypedImportBuffer::get_data_block_pointers(), Catalog_Namespace::Catalog::getPhysicalTablesDescriptors(), load_callback_, loadToShard(), TableDescriptor::nShards, and table_desc_.

Referenced by load(), and loadNoCheckpoint().

                                                       {
   if (load_callback_) {
     auto data_blocks = TypedImportBuffer::get_data_block_pointers(import_buffers);
     return load_callback_(import_buffers, data_blocks, row_count);
   }
   if (table_desc_->nShards) {
     std::vector<OneShardBuffers> all_shard_import_buffers;
     std::vector<size_t> all_shard_row_counts;
     const auto shard_tables = catalog_.getPhysicalTablesDescriptors(table_desc_);
     distributeToShards(all_shard_import_buffers,
                        all_shard_row_counts,
                        import_buffers,
                        row_count,
                        shard_tables.size(),
                        session_info);
     bool success = true;
     for (size_t shard_idx = 0; shard_idx < shard_tables.size(); ++shard_idx) {
       success = success && loadToShard(all_shard_import_buffers[shard_idx],
                                        all_shard_row_counts[shard_idx],
                                        shard_tables[shard_idx],
                                        checkpoint,
                                        session_info);
     }
     return success;
   }
   return loadToShard(import_buffers, row_count, table_desc_, checkpoint, session_info);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool import_export::Loader::loadNoCheckpoint	(	const std::vector< std::unique_ptr< TypedImportBuffer >> &	import_buffers,
		const size_t	row_count,
		const Catalog_Namespace::SessionInfo *	session_info
	)

virtual

Definition at line 2754 of file Importer.cpp.

References loadImpl().

                                                       {
   return loadImpl(import_buffers, row_count, false, session_info);
 }

Here is the call graph for this function:

bool import_export::Loader::loadToShard	(	const std::vector< std::unique_ptr< TypedImportBuffer >> &	import_buffers,
		size_t	row_count,
		const TableDescriptor *	shard_table,
		bool	checkpoint,
		const Catalog_Namespace::SessionInfo *	session_info
	)

private

Definition at line 3075 of file Importer.cpp.

References Fragmenter_Namespace::InsertData::columnIds, Fragmenter_Namespace::InsertData::data, logger::ERROR, error_msg_, TableDescriptor::fragmenter, import_export::TypedImportBuffer::get_data_block_pointers(), insert_data_, Fragmenter_Namespace::InsertData::is_default, isAddingColumns(), loader_mutex_, LOG, Fragmenter_Namespace::InsertData::numRows, and TableDescriptor::tableName.

Referenced by loadImpl().

                                                       {
   std::unique_lock<std::mutex> loader_lock(loader_mutex_);
   Fragmenter_Namespace::InsertData ins_data(insert_data_);
   ins_data.numRows = row_count;
   bool success = false;
   try {
     ins_data.data = TypedImportBuffer::get_data_block_pointers(import_buffers);
   } catch (std::exception& e) {
     std::ostringstream oss;
     oss << "Exception when loading Table " << shard_table->tableName << ", issue was "
         << e.what();
 
     LOG(ERROR) << oss.str();
     error_msg_ = oss.str();
     return success;
   }
   if (isAddingColumns()) {
     // when Adding columns we omit any columns except the ones being added
     ins_data.columnIds.clear();
     ins_data.is_default.clear();
     for (auto& buffer : import_buffers) {
       ins_data.columnIds.push_back(buffer->getColumnDesc()->columnId);
       ins_data.is_default.push_back(true);
     }
   } else {
     ins_data.is_default.resize(ins_data.columnIds.size(), false);
   }
   // release loader_lock so that in InsertOrderFragmenter::insertDat
   // we can have multiple threads sort/shuffle InsertData
   loader_lock.unlock();
   success = true;
   {
     try {
       if (checkpoint) {
         shard_table->fragmenter->insertData(ins_data);
       } else {
         shard_table->fragmenter->insertDataNoCheckpoint(ins_data);
       }
     } catch (std::exception& e) {
       std::ostringstream oss;
       oss << "Fragmenter Insert Exception when processing Table  "
           << shard_table->tableName << " issue was " << e.what();
 
       LOG(ERROR) << oss.str();
       loader_lock.lock();
       error_msg_ = oss.str();
       success = false;
     }
   }
   return success;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void import_export::Loader::setAddingColumns ( const bool adding_columns )

inline

Definition at line 599 of file Importer.h.

References adding_columns_.

599 { adding_columns_ = adding_columns; }

import_export::Loader::adding_columns_

bool adding_columns_

Definition: Importer.h:652

void import_export::Loader::setTableEpochs ( const std::vector< Catalog_Namespace::TableEpochInfo > & table_epochs )

virtual

Definition at line 4679 of file Importer.cpp.

References getCatalog(), and Catalog_Namespace::Catalog::setTableEpochs().

                                                                     {
   getCatalog().setTableEpochs(getCatalog().getCurrentDB().dbId, table_epochs);
 }

Here is the call graph for this function:

Member Data Documentation

bool import_export::Loader::adding_columns_ = false

private

Definition at line 652 of file Importer.h.

Referenced by isAddingColumns(), and setAddingColumns().

Catalog_Namespace::Catalog& import_export::Loader::catalog_

protected

Definition at line 621 of file Importer.h.

Referenced by distributeToShardsNewColumns(), dropColumns(), getCatalog(), init(), and loadImpl().

std::list<const ColumnDescriptor*> import_export::Loader::column_descs_

protected

Definition at line 623 of file Importer.h.

Referenced by distributeToShardsExistingColumns(), get_column_descs(), and init().

std::map<int, StringDictionary*> import_export::Loader::dict_map_

protected

Definition at line 626 of file Importer.h.

Referenced by getStringDict(), and init().

std::string import_export::Loader::error_msg_

private

Definition at line 654 of file Importer.h.

Referenced by getErrorMessage(), and loadToShard().

Fragmenter_Namespace::InsertData import_export::Loader::insert_data_

protected

Definition at line 625 of file Importer.h.

Referenced by init(), and loadToShard().

LoadCallbackType import_export::Loader::load_callback_

protected

Definition at line 624 of file Importer.h.

Referenced by loadImpl().

std::mutex import_export::Loader::loader_mutex_

private

Definition at line 653 of file Importer.h.

Referenced by loadToShard().

const TableDescriptor* import_export::Loader::table_desc_

protected

Definition at line 622 of file Importer.h.

Referenced by distributeToShards(), distributeToShardsExistingColumns(), distributeToShardsNewColumns(), dropColumns(), getTableDesc(), init(), and loadImpl().

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

/home/jenkins-slave/workspace/core-os-doxygen/ImportExport/Importer.h
/home/jenkins-slave/workspace/core-os-doxygen/ImportExport/Importer.cpp

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation