ForeignStorageInterface Class Reference

#include <ForeignStorageInterface.h>

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

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

Detailed Description

Definition at line 218 of file ForeignStorageInterface.h.

Member Function Documentation

void ForeignStorageInterface::destroy ( )

static

Definition at line 225 of file ForeignStorageInterface.cpp.

References managers_map_, and persistent_storage_interfaces_.

Referenced by startMapdServer().

                                      {
  persistent_storage_interfaces_.clear();
  managers_map_.clear();
}

Here is the caller graph for this function:

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

static

Definition at line 148 of file ForeignStorageInterface.cpp.

References CHECK, managers_map_, persistent_storage_interfaces_mutex_, and table_persistent_storage_interface_map_.

Referenced by File_Namespace::GlobalFileMgr::getFileMgr(), PersistentStorageMgr::isChunkPrefixCacheable(), and 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:

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

static

prepare table options and modify columns

Definition at line 183 of file ForeignStorageInterface.cpp.

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

Referenced by Catalog_Namespace::Catalog::createTable().

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

Here is the caller graph for this function:

void ForeignStorageInterface::registerPersistentStorageInterface ( std::unique_ptr< PersistentForeignStorageInterface >  persistent_foreign_storage )

static

Definition at line 168 of file ForeignStorageInterface.cpp.

References CHECK, persistent_storage_interfaces_, and persistent_storage_interfaces_mutex_.

Referenced by registerArrowCsvForeignStorage(), and registerArrowForeignStorage().

                                                                                 {
  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);
}

Here is the caller graph for this function:

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

static

ids are created

Definition at line 198 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.

Referenced by Catalog_Namespace::Catalog::createTable().

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

Here is the caller graph for this function:

Member Data Documentation

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

staticprivate

Definition at line 244 of file ForeignStorageInterface.h.

Referenced by destroy(), and lookupBufferManager().

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

staticprivate

Definition at line 240 of file ForeignStorageInterface.h.

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

std::mutex ForeignStorageInterface::persistent_storage_interfaces_mutex_

staticprivate

Definition at line 245 of file ForeignStorageInterface.h.

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

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

staticprivate

Definition at line 242 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