ForeignStorageInterface Class Reference

#include <ForeignStorageInterface.h>

Public Member Functions
	ForeignStorageInterface ()
	~ForeignStorageInterface ()
	ForeignStorageInterface (const ForeignStorageInterface &other)=delete
	ForeignStorageInterface (ForeignStorageInterface &&other)=delete
ForeignStorageInterface &	operator= (const ForeignStorageInterface &other)=delete
ForeignStorageInterface &	operator= (ForeignStorageInterface &&other)=delete
Data_Namespace::AbstractBufferMgr *	lookupBufferManager (const int db_id, const int table_id)
void	dropBufferManager (const int db_id, const int table_id)
void	registerPersistentStorageInterface (std::unique_ptr< PersistentForeignStorageInterface > persistent_foreign_storage)
void	prepareTable (const int db_id, TableDescriptor &td, std::list< ColumnDescriptor > &cols)
	prepare table options and modify columns More...
void	registerTable (Catalog_Namespace::Catalog *catalog, const TableDescriptor &td, const std::list< ColumnDescriptor > &cols)
	ids are created More...

Private Attributes
std::unordered_map < std::string, std::unique_ptr < PersistentForeignStorageInterface > >	persistent_storage_interfaces_
std::map< std::pair< int, int > , PersistentForeignStorageInterface * >	table_persistent_storage_interface_map_
std::map< std::pair< int, int > , std::unique_ptr < ForeignStorageBufferMgr > >	managers_map_
std::mutex	persistent_storage_interfaces_mutex_

Detailed Description

Definition at line 220 of file ForeignStorageInterface.h.

Constructor & Destructor Documentation

ForeignStorageInterface::ForeignStorageInterface ( )

inline

Definition at line 222 of file ForeignStorageInterface.h.

{}

ForeignStorageInterface::~ForeignStorageInterface ( )

inline

Definition at line 223 of file ForeignStorageInterface.h.

{}

ForeignStorageInterface::ForeignStorageInterface ( const ForeignStorageInterface &  other )

delete

ForeignStorageInterface::ForeignStorageInterface ( ForeignStorageInterface &&  other )

delete

Member Function Documentation

void ForeignStorageInterface::dropBufferManager	(	const int	db_id,
		const int	table_id
	)

Definition at line 169 of file ForeignStorageInterface.cpp.

References managers_map_, and persistent_storage_interfaces_mutex_.

                                                                                   {
  std::lock_guard<std::mutex> persistent_storage_interfaces_lock(
      persistent_storage_interfaces_mutex_);
  managers_map_.erase(std::make_pair(db_id, table_id));
}

Data_Namespace::AbstractBufferMgr * ForeignStorageInterface::lookupBufferManager	(	const int	db_id,
		const int	table_id
	)

Definition at line 149 of file ForeignStorageInterface.cpp.

References CHECK, managers_map_, persistent_storage_interfaces_mutex_, and table_persistent_storage_interface_map_.

Referenced by registerTable().

                        {
  auto key = std::make_pair(db_id, table_id);
  if (managers_map_.count(key)) {
    return managers_map_[key].get();
  }

  std::lock_guard<std::mutex> persistent_storage_interfaces_lock(
      persistent_storage_interfaces_mutex_);
  const auto it = table_persistent_storage_interface_map_.find(key);
  if (it == table_persistent_storage_interface_map_.end()) {
    return nullptr;
  }
  const auto it_ok = managers_map_.emplace(
      key, std::make_unique<ForeignStorageBufferMgr>(db_id, table_id, it->second));
  CHECK(it_ok.second);
  return it_ok.first->second.get();
}

Here is the caller graph for this function:

ForeignStorageInterface& ForeignStorageInterface::operator= ( const ForeignStorageInterface &  other )

delete

ForeignStorageInterface& ForeignStorageInterface::operator= ( ForeignStorageInterface &&  other )

delete

void ForeignStorageInterface::prepareTable	(	const int	db_id,
		TableDescriptor &	td,
		std::list< ColumnDescriptor > &	cols
	)

prepare table options and modify columns

Definition at line 190 of file ForeignStorageInterface.cpp.

References parseStorageType(), persistent_storage_interfaces_, persistent_storage_interfaces_mutex_, TableDescriptor::storageType, and run_benchmark_import::type.

                                                                            {
  auto type = parseStorageType(td.storageType);
  std::unique_lock<std::mutex> persistent_storage_interfaces_lock(
      persistent_storage_interfaces_mutex_);
  const auto it = persistent_storage_interfaces_.find(type.first);
  if (it == persistent_storage_interfaces_.end()) {
    throw std::runtime_error("storage type " + type.first + " not supported");
  }
  auto& p = it->second;
  persistent_storage_interfaces_lock.unlock();
  p->prepareTable(db_id, type.second, td, cols);
}

Here is the call graph for this function:

void ForeignStorageInterface::registerPersistentStorageInterface

(

std::unique_ptr< PersistentForeignStorageInterface >

persistent_foreign_storage

)

Definition at line 175 of file ForeignStorageInterface.cpp.

References CHECK, persistent_storage_interfaces_, and persistent_storage_interfaces_mutex_.

                                                                                 {
  std::lock_guard<std::mutex> persistent_storage_interfaces_lock(
      persistent_storage_interfaces_mutex_);
  const auto it_ok = persistent_storage_interfaces_.emplace(
      persistent_foreign_storage->getType(), std::move(persistent_foreign_storage));
  CHECK(it_ok.second);
}

void ForeignStorageInterface::registerTable	(	Catalog_Namespace::Catalog *	catalog,
		const TableDescriptor &	td,
		const std::list< ColumnDescriptor > &	cols
	)

ids are created

Definition at line 205 of file ForeignStorageInterface.cpp.

References Catalog_Namespace::DBMetadata::dbId, Catalog_Namespace::Catalog::getCurrentDB(), lookupBufferManager(), parseStorageType(), persistent_storage_interfaces_, persistent_storage_interfaces_mutex_, TableDescriptor::storageType, table_persistent_storage_interface_map_, TableDescriptor::tableId, and run_benchmark_import::type.

                                                                                   {
  const int table_id = td.tableId;
  auto type = parseStorageType(td.storageType);

  std::unique_lock<std::mutex> persistent_storage_interfaces_lock(
      persistent_storage_interfaces_mutex_);
  const auto it = persistent_storage_interfaces_.find(type.first);
  if (it == persistent_storage_interfaces_.end()) {
    throw std::runtime_error("storage type " + type.first + " not supported");
  }

  auto db_id = catalog->getCurrentDB().dbId;
  const auto it_ok = table_persistent_storage_interface_map_.emplace(
      std::make_pair(db_id, table_id), it->second.get());
  // this check fails if we create table, drop it and create again
  // CHECK(it_ok.second);
  persistent_storage_interfaces_lock.unlock();
  it_ok.first->second->registerTable(catalog,
                                     it_ok.first->first,
                                     type.second,
                                     td,
                                     cols,
                                     lookupBufferManager(db_id, table_id));
}

Here is the call graph for this function:

Member Data Documentation

std::map<std::pair<int, int>, std::unique_ptr<ForeignStorageBufferMgr> > ForeignStorageInterface::managers_map_

private

Definition at line 252 of file ForeignStorageInterface.h.

Referenced by dropBufferManager(), and lookupBufferManager().

std::unordered_map<std::string, std::unique_ptr<PersistentForeignStorageInterface> > ForeignStorageInterface::persistent_storage_interfaces_

private

Definition at line 249 of file ForeignStorageInterface.h.

Referenced by prepareTable(), registerPersistentStorageInterface(), and registerTable().

std::mutex ForeignStorageInterface::persistent_storage_interfaces_mutex_

private

Definition at line 253 of file ForeignStorageInterface.h.

Referenced by dropBufferManager(), lookupBufferManager(), prepareTable(), registerPersistentStorageInterface(), and registerTable().

std::map<std::pair<int, int>, PersistentForeignStorageInterface*> ForeignStorageInterface::table_persistent_storage_interface_map_

private

Definition at line 251 of file ForeignStorageInterface.h.

Referenced by lookupBufferManager(), and registerTable().

---

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

• /home/jenkins-slave/workspace/core-os-doxygen/DataMgr/ForeignStorage/ForeignStorageInterface.h
• /home/jenkins-slave/workspace/core-os-doxygen/DataMgr/ForeignStorage/ForeignStorageInterface.cpp