#include <PersistentStorageMgr.h>

Inheritance diagram for PersistentStorageMgr:

Collaboration diagram for PersistentStorageMgr:

Public Member Functions
	PersistentStorageMgr (const std::string &data_dir, const size_t num_reader_threads, const File_Namespace::DiskCacheConfig &disk_cache_config)

AbstractBuffer *	createBuffer (const ChunkKey &chunk_key, const size_t page_size, const size_t initial_size) override

void	deleteBuffer (const ChunkKey &chunk_key, const bool purge) override

void	deleteBuffersWithPrefix (const ChunkKey &chunk_key_prefix, const bool purge) override

AbstractBuffer *	getBuffer (const ChunkKey &chunk_key, const size_t num_bytes) override

void	fetchBuffer (const ChunkKey &chunk_key, AbstractBuffer *destination_buffer, const size_t num_bytes) override

AbstractBuffer *	putBuffer (const ChunkKey &chunk_key, AbstractBuffer *source_buffer, const size_t num_bytes) override

void	getChunkMetadataVecForKeyPrefix (ChunkMetadataVector &chunk_metadata, const ChunkKey &chunk_key_prefix) override

bool	isBufferOnDevice (const ChunkKey &chunk_key) override

std::string	printSlabs () override

size_t	getMaxSize () override

size_t	getInUseSize () override

size_t	getAllocated () override

bool	isAllocationCapped () override

void	checkpoint () override

void	checkpoint (const int db_id, const int tb_id) override

AbstractBuffer *	alloc (const size_t num_bytes) override

void	free (AbstractBuffer *buffer) override

MgrType	getMgrType () override

std::string	getStringMgrType () override

size_t	getNumChunks () override

void	removeTableRelatedDS (const int db_id, const int table_id) override

void	removeMutableTableCacheData (const int db_id, const int table_id) const

File_Namespace::GlobalFileMgr *	getGlobalFileMgr () const

foreign_storage::ForeignStorageMgr *	getForeignStorageMgr () const

foreign_storage::ForeignStorageCache *	getDiskCache () const

const File_Namespace::DiskCacheConfig	getDiskCacheConfig () const

const std::shared_ptr < ForeignStorageInterface >	getForeignStorageInterface () const

Protected Member Functions
bool	isForeignStorage (const ChunkKey &chunk_key) const

AbstractBufferMgr *	getStorageMgrForTableKey (const ChunkKey &table_key) const

bool	isChunkPrefixCacheable (const ChunkKey &chunk_prefix) const

int	recoverDataWrapperIfCachedAndGetHighestFragId (const ChunkKey &table_key)

Protected Attributes
std::unique_ptr < File_Namespace::GlobalFileMgr >	global_file_mgr_

std::unique_ptr < foreign_storage::ForeignStorageMgr >	foreign_storage_mgr_

std::unique_ptr < foreign_storage::ForeignStorageCache >	disk_cache_

File_Namespace::DiskCacheConfig	disk_cache_config_

std::shared_ptr < ForeignStorageInterface >	fsi_

Detailed Description

Definition at line 26 of file PersistentStorageMgr.h.

Constructor & Destructor Documentation

PersistentStorageMgr::PersistentStorageMgr	(	const std::string &	data_dir,
		const size_t	num_reader_threads,
		const File_Namespace::DiskCacheConfig &	disk_cache_config
	)

Definition at line 24 of file PersistentStorageMgr.cpp.

References CHECK, disk_cache_, disk_cache_config_, foreign_storage_mgr_, fsi_, global_file_mgr_, File_Namespace::DiskCacheConfig::isEnabled(), File_Namespace::DiskCacheConfig::isEnabledForFSI(), File_Namespace::DiskCacheConfig::isEnabledForMutableTables(), registerArrowCsvForeignStorage(), and registerArrowForeignStorage().

     : AbstractBufferMgr(0), disk_cache_config_(disk_cache_config) {
   fsi_ = std::make_shared<ForeignStorageInterface>();
   ::registerArrowForeignStorage(fsi_);
   ::registerArrowCsvForeignStorage(fsi_);
 
   disk_cache_ =
       disk_cache_config_.isEnabled()
           ? std::make_unique<foreign_storage::ForeignStorageCache>(disk_cache_config)
           : nullptr;
   if (disk_cache_config_.isEnabledForMutableTables()) {
     CHECK(disk_cache_);
     global_file_mgr_ = std::make_unique<File_Namespace::CachingGlobalFileMgr>(
         0, fsi_, data_dir, num_reader_threads, disk_cache_.get());
   } else {
     global_file_mgr_ = std::make_unique<File_Namespace::GlobalFileMgr>(
         0, fsi_, data_dir, num_reader_threads);
   }
 
   if (disk_cache_config_.isEnabledForFSI()) {
     CHECK(disk_cache_);
     foreign_storage_mgr_ =
         std::make_unique<foreign_storage::CachingForeignStorageMgr>(disk_cache_.get());
   } else {
     foreign_storage_mgr_ = std::make_unique<foreign_storage::ForeignStorageMgr>();
   }
 }

Here is the call graph for this function:

Member Function Documentation

AbstractBuffer * PersistentStorageMgr::alloc ( const size_t num_bytes )

override

Definition at line 130 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

                                                                   {
   return global_file_mgr_->alloc(num_bytes);
 }

void PersistentStorageMgr::checkpoint ( )

override

Definition at line 122 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

                                       {
   global_file_mgr_->checkpoint();
 }

void PersistentStorageMgr::checkpoint	(	const int	db_id,
		const int	tb_id
	)

override

Definition at line 126 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

                                                                       {
   global_file_mgr_->checkpoint(db_id, tb_id);
 }

AbstractBuffer * PersistentStorageMgr::createBuffer	(	const ChunkKey &	chunk_key,
		const size_t	page_size,
		const size_t	initial_size
	)

override

Definition at line 55 of file PersistentStorageMgr.cpp.

References getStorageMgrForTableKey().

                                                                               {
   return getStorageMgrForTableKey(chunk_key)->createBuffer(
       chunk_key, page_size, initial_size);
 }

Here is the call graph for this function:

void PersistentStorageMgr::deleteBuffer	(	const ChunkKey &	chunk_key,
		const bool	purge
	)

override

Definition at line 62 of file PersistentStorageMgr.cpp.

References getStorageMgrForTableKey().

                                                                                    {
   getStorageMgrForTableKey(chunk_key)->deleteBuffer(chunk_key, purge);
 }

Here is the call graph for this function:

void PersistentStorageMgr::deleteBuffersWithPrefix	(	const ChunkKey &	chunk_key_prefix,
		const bool	purge
	)

override

Definition at line 66 of file PersistentStorageMgr.cpp.

References getStorageMgrForTableKey().

                                                                      {
   getStorageMgrForTableKey(chunk_key_prefix)
       ->deleteBuffersWithPrefix(chunk_key_prefix, purge);
 }

Here is the call graph for this function:

void PersistentStorageMgr::fetchBuffer	(	const ChunkKey &	chunk_key,
		AbstractBuffer *	destination_buffer,
		const size_t	num_bytes
	)

override

Definition at line 77 of file PersistentStorageMgr.cpp.

References getStorageMgrForTableKey().

                                                                {
   getStorageMgrForTableKey(chunk_key)->fetchBuffer(
       chunk_key, destination_buffer, num_bytes);
 }

Here is the call graph for this function:

void PersistentStorageMgr::free ( AbstractBuffer * buffer )

override

Definition at line 134 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

                                                       {
   global_file_mgr_->free(buffer);
 }

size_t PersistentStorageMgr::getAllocated ( )

override

Definition at line 114 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

                                           {
   return global_file_mgr_->getAllocated();
 }

AbstractBuffer * PersistentStorageMgr::getBuffer	(	const ChunkKey &	chunk_key,
		const size_t	num_bytes
	)

override

Definition at line 72 of file PersistentStorageMgr.cpp.

References getStorageMgrForTableKey().

                                                                         {
   return getStorageMgrForTableKey(chunk_key)->getBuffer(chunk_key, num_bytes);
 }

Here is the call graph for this function:

void PersistentStorageMgr::getChunkMetadataVecForKeyPrefix	(	ChunkMetadataVector &	chunk_metadata,
		const ChunkKey &	chunk_key_prefix
	)

override

Definition at line 91 of file PersistentStorageMgr.cpp.

References getStorageMgrForTableKey().

                                 {
   getStorageMgrForTableKey(key_prefix)
       ->getChunkMetadataVecForKeyPrefix(chunk_metadata, key_prefix);
 }

Here is the call graph for this function:

foreign_storage::ForeignStorageCache * PersistentStorageMgr::getDiskCache ( ) const

Definition at line 202 of file PersistentStorageMgr.cpp.

References disk_cache_.

Referenced by Catalog_Namespace::anonymous_namespace{Catalog.cpp}::clear_cached_table_data().

                                                                              {
   return disk_cache_ ? disk_cache_.get() : nullptr;
 }

Here is the caller graph for this function:

const File_Namespace::DiskCacheConfig PersistentStorageMgr::getDiskCacheConfig ( ) const

inline

Definition at line 66 of file PersistentStorageMgr.h.

                                                                         {
     return disk_cache_config_;
   }

const std::shared_ptr<ForeignStorageInterface> PersistentStorageMgr::getForeignStorageInterface ( ) const

inline

Definition at line 69 of file PersistentStorageMgr.h.

             {
     return fsi_;
   }

foreign_storage::ForeignStorageMgr * PersistentStorageMgr::getForeignStorageMgr ( ) const

Definition at line 198 of file PersistentStorageMgr.cpp.

References foreign_storage_mgr_.

Referenced by anonymous_namespace{RelAlgExecutor.cpp}::set_parallelism_hints().

                                                                                    {
   return foreign_storage_mgr_.get();
 }

Here is the caller graph for this function:

File_Namespace::GlobalFileMgr * PersistentStorageMgr::getGlobalFileMgr ( ) const

Definition at line 150 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

                                                                           {
   return global_file_mgr_.get();
 }

size_t PersistentStorageMgr::getInUseSize ( )

override

Definition at line 110 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

                                           {
   return global_file_mgr_->getInUseSize();
 }

size_t PersistentStorageMgr::getMaxSize ( )

override

Definition at line 106 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

                                         {
   return global_file_mgr_->getMaxSize();
 }

MgrType PersistentStorageMgr::getMgrType ( )

override

Definition at line 138 of file PersistentStorageMgr.cpp.

                                          {
   return PERSISTENT_STORAGE_MGR;
 }

size_t PersistentStorageMgr::getNumChunks ( )

override

Definition at line 146 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

                                           {
   return global_file_mgr_->getNumChunks();
 }

AbstractBufferMgr * PersistentStorageMgr::getStorageMgrForTableKey ( const ChunkKey & table_key ) const

protected

Definition at line 189 of file PersistentStorageMgr.cpp.

References foreign_storage_mgr_, global_file_mgr_, and isForeignStorage().

Referenced by createBuffer(), deleteBuffer(), deleteBuffersWithPrefix(), fetchBuffer(), getBuffer(), getChunkMetadataVecForKeyPrefix(), putBuffer(), and removeTableRelatedDS().

                                      {
   if (isForeignStorage(table_key)) {
     return foreign_storage_mgr_.get();
   } else {
     return global_file_mgr_.get();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string PersistentStorageMgr::getStringMgrType ( )

override

Definition at line 142 of file PersistentStorageMgr.cpp.

                                                  {
   return ToString(PERSISTENT_STORAGE_MGR);
 }

bool PersistentStorageMgr::isAllocationCapped ( )

override

Definition at line 118 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

                                               {
   return global_file_mgr_->isAllocationCapped();
 }

bool PersistentStorageMgr::isBufferOnDevice ( const ChunkKey & chunk_key )

override

Definition at line 98 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

                                                                      {
   return global_file_mgr_->isBufferOnDevice(chunk_key);
 }

bool PersistentStorageMgr::isChunkPrefixCacheable ( const ChunkKey & chunk_prefix ) const

protected

bool PersistentStorageMgr::isForeignStorage ( const ChunkKey & chunk_key ) const

protected

Definition at line 169 of file PersistentStorageMgr.cpp.

References CHECK, CHUNK_KEY_DB_IDX, CHUNK_KEY_TABLE_IDX, StorageType::FOREIGN_TABLE, Catalog_Namespace::SysCatalog::getCatalog(), has_table_prefix(), and Catalog_Namespace::SysCatalog::instance().

Referenced by getStorageMgrForTableKey().

                                                                            {
   CHECK(has_table_prefix(chunk_key));
   auto db_id = chunk_key[CHUNK_KEY_DB_IDX];
   auto table_id = chunk_key[CHUNK_KEY_TABLE_IDX];
   auto catalog = Catalog_Namespace::SysCatalog::instance().getCatalog(db_id);
 
   // if catalog doesnt exist at this point we must be in an old migration.
   // Old migration can not, at this point 5.5.1, be using foreign storage
   // so this hack is to avoid the crash, when migrating old
   // catalogs that have not been upgraded over time due to issue
   // [BE-5728]
   if (!catalog) {
     return false;
   }
 
   auto table = catalog->getMetadataForTable(table_id, false);
   CHECK(table);
   return table->storageType == StorageType::FOREIGN_TABLE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string PersistentStorageMgr::printSlabs ( )

override

Definition at line 102 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

                                            {
   return global_file_mgr_->printSlabs();
 }

AbstractBuffer * PersistentStorageMgr::putBuffer	(	const ChunkKey &	chunk_key,
		AbstractBuffer *	source_buffer,
		const size_t	num_bytes
	)

override

Definition at line 84 of file PersistentStorageMgr.cpp.

References getStorageMgrForTableKey().

                                                                         {
   return getStorageMgrForTableKey(chunk_key)->putBuffer(
       chunk_key, source_buffer, num_bytes);
 }

Here is the call graph for this function:

int PersistentStorageMgr::recoverDataWrapperIfCachedAndGetHighestFragId ( const ChunkKey & table_key )

protected

void PersistentStorageMgr::removeMutableTableCacheData	(	const int	db_id,
		const int	table_id
	)		const

Definition at line 158 of file PersistentStorageMgr.cpp.

References disk_cache_config_, global_file_mgr_, and File_Namespace::DiskCacheConfig::isEnabledForMutableTables().

Referenced by Data_Namespace::DataMgr::removeMutableTableDiskCacheData().

                                                                               {
   if (disk_cache_config_.isEnabledForMutableTables()) {
     // If the disk cache supports mutable tables then clear the cached data.
     if (auto cfm =
             dynamic_cast<File_Namespace::CachingGlobalFileMgr*>(global_file_mgr_.get())) {
       cfm->removeCachedData(db_id, tb_id);
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PersistentStorageMgr::removeTableRelatedDS	(	const int	db_id,
		const int	table_id
	)

override

Definition at line 154 of file PersistentStorageMgr.cpp.

References getStorageMgrForTableKey().

                                                                                    {
   getStorageMgrForTableKey({db_id, table_id})->removeTableRelatedDS(db_id, table_id);
 }

Here is the call graph for this function:

Member Data Documentation

std::unique_ptr<foreign_storage::ForeignStorageCache> PersistentStorageMgr::disk_cache_

protected

Definition at line 82 of file PersistentStorageMgr.h.

Referenced by getDiskCache(), and PersistentStorageMgr().

File_Namespace::DiskCacheConfig PersistentStorageMgr::disk_cache_config_

protected

Definition at line 83 of file PersistentStorageMgr.h.

Referenced by PersistentStorageMgr(), and removeMutableTableCacheData().

std::unique_ptr<foreign_storage::ForeignStorageMgr> PersistentStorageMgr::foreign_storage_mgr_

protected

Definition at line 81 of file PersistentStorageMgr.h.

Referenced by getForeignStorageMgr(), getStorageMgrForTableKey(), and PersistentStorageMgr().

std::shared_ptr<ForeignStorageInterface> PersistentStorageMgr::fsi_

protected

Definition at line 84 of file PersistentStorageMgr.h.

Referenced by PersistentStorageMgr().

std::unique_ptr<File_Namespace::GlobalFileMgr> PersistentStorageMgr::global_file_mgr_

protected

Definition at line 80 of file PersistentStorageMgr.h.

Referenced by alloc(), checkpoint(), free(), getAllocated(), getGlobalFileMgr(), getInUseSize(), getMaxSize(), getNumChunks(), getStorageMgrForTableKey(), isAllocationCapped(), isBufferOnDevice(), PersistentStorageMgr(), printSlabs(), and removeMutableTableCacheData().

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

/home/jenkins-slave/workspace/core-os-doxygen/DataMgr/PersistentStorageMgr/PersistentStorageMgr.h
/home/jenkins-slave/workspace/core-os-doxygen/DataMgr/PersistentStorageMgr/PersistentStorageMgr.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation