OmniSciDB  ba1bac9284
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
PersistentStorageMgr Class Reference

#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)
 
AbstractBuffercreateBuffer (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
 
AbstractBuffergetBuffer (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
 
AbstractBufferputBuffer (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
 
void clearSlabs () 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
 
AbstractBufferalloc (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
 
File_Namespace::GlobalFileMgrgetGlobalFileMgr () const
 
foreign_storage::ForeignStorageMgrgetForeignStorageMgr () const
 
foreign_storage::ForeignStorageCachegetDiskCache () const
 
const
File_Namespace::DiskCacheConfig 
getDiskCacheConfig () const
 
const std::shared_ptr
< ForeignStorageInterface
getForeignStorageInterface () const
 

Static Public Member Functions

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

Protected Member Functions

bool isForeignStorage (const ChunkKey &chunk_key) const
 
AbstractBufferMgrgetStorageMgrForTableKey (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 35 of file PersistentStorageMgr.cpp.

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

Referenced by createPersistentStorageMgr().

39  : AbstractBufferMgr(0), disk_cache_config_(disk_cache_config) {
40  fsi_ = std::make_shared<ForeignStorageInterface>();
43 
44  global_file_mgr_ = std::make_unique<File_Namespace::GlobalFileMgr>(
45  0, fsi_, data_dir, num_reader_threads);
46  disk_cache_ =
48  ? std::make_unique<foreign_storage::ForeignStorageCache>(disk_cache_config)
49  : nullptr;
52  ? std::make_unique<foreign_storage::CachingForeignStorageMgr>(disk_cache_.get())
53  : std::make_unique<foreign_storage::ForeignStorageMgr>();
54 }
void registerArrowForeignStorage(std::shared_ptr< ForeignStorageInterface > fsi)
void registerArrowCsvForeignStorage(std::shared_ptr< ForeignStorageInterface > fsi)
std::shared_ptr< ForeignStorageInterface > fsi_
std::unique_ptr< foreign_storage::ForeignStorageCache > disk_cache_
File_Namespace::DiskCacheConfig disk_cache_config_
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
std::unique_ptr< foreign_storage::ForeignStorageMgr > foreign_storage_mgr_

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Member Function Documentation

AbstractBuffer * PersistentStorageMgr::alloc ( const size_t  num_bytes)
override

Definition at line 168 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

168  {
169  return global_file_mgr_->alloc(num_bytes);
170 }
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
void PersistentStorageMgr::checkpoint ( )
override

Definition at line 160 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

160  {
161  global_file_mgr_->checkpoint();
162 }
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
void PersistentStorageMgr::checkpoint ( const int  db_id,
const int  tb_id 
)
override

Definition at line 164 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

164  {
165  global_file_mgr_->checkpoint(db_id, tb_id);
166 }
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
void PersistentStorageMgr::clearSlabs ( )
override

Definition at line 140 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

140  {
141  global_file_mgr_->clearSlabs();
142 }
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
AbstractBuffer * PersistentStorageMgr::createBuffer ( const ChunkKey chunk_key,
const size_t  page_size,
const size_t  initial_size 
)
override

Definition at line 56 of file PersistentStorageMgr.cpp.

References getStorageMgrForTableKey().

Referenced by MutableCachePersistentStorageMgr::createBuffer().

58  {
59  return getStorageMgrForTableKey(chunk_key)->createBuffer(
60  chunk_key, page_size, initial_size);
61 }
AbstractBufferMgr * getStorageMgrForTableKey(const ChunkKey &table_key) const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

Definition at line 24 of file PersistentStorageMgr.cpp.

References File_Namespace::DiskCacheConfig::isEnabledForMutableTables(), and PersistentStorageMgr().

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

27  {
28  if (config.isEnabledForMutableTables()) {
29  return new MutableCachePersistentStorageMgr(data_dir, num_reader_threads, config);
30  } else {
31  return new PersistentStorageMgr(data_dir, num_reader_threads, config);
32  }
33 }
PersistentStorageMgr(const std::string &data_dir, const size_t num_reader_threads, const File_Namespace::DiskCacheConfig &disk_cache_config)

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

Definition at line 63 of file PersistentStorageMgr.cpp.

References getStorageMgrForTableKey().

Referenced by MutableCachePersistentStorageMgr::deleteBuffer().

63  {
64  getStorageMgrForTableKey(chunk_key)->deleteBuffer(chunk_key, purge);
65 }
AbstractBufferMgr * getStorageMgrForTableKey(const ChunkKey &table_key) const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

Definition at line 67 of file PersistentStorageMgr.cpp.

References getStorageMgrForTableKey().

Referenced by MutableCachePersistentStorageMgr::deleteBuffersWithPrefix().

68  {
69  getStorageMgrForTableKey(chunk_key_prefix)
70  ->deleteBuffersWithPrefix(chunk_key_prefix, purge);
71 }
AbstractBufferMgr * getStorageMgrForTableKey(const ChunkKey &table_key) const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

Definition at line 78 of file PersistentStorageMgr.cpp.

References Data_Namespace::AbstractBuffer::copyTo(), disk_cache_, getStorageMgrForTableKey(), isChunkPrefixCacheable(), and isForeignStorage().

80  {
81  AbstractBufferMgr* mgr = getStorageMgrForTableKey(chunk_key);
82  if (isChunkPrefixCacheable(chunk_key)) {
83  AbstractBuffer* buffer = disk_cache_->getCachedChunkIfExists(chunk_key);
84  if (buffer) {
85  buffer->copyTo(destination_buffer, num_bytes);
86  return;
87  } else {
88  mgr->fetchBuffer(chunk_key, destination_buffer, num_bytes);
89  if (!isForeignStorage(chunk_key)) {
90  // Foreign storage will read into cache buffers directly if enabled, so we do
91  // not want to cache foreign table chunks here as they will already be cached.
92  disk_cache_->cacheChunk(chunk_key, destination_buffer);
93  }
94  return;
95  }
96  }
97  mgr->fetchBuffer(chunk_key, destination_buffer, num_bytes);
98 }
bool isForeignStorage(const ChunkKey &chunk_key) const
An AbstractBuffer is a unit of data management for a data manager.
bool isChunkPrefixCacheable(const ChunkKey &chunk_prefix) const
std::unique_ptr< foreign_storage::ForeignStorageCache > disk_cache_
void copyTo(AbstractBuffer *destination_buffer, const size_t num_bytes=0)
AbstractBufferMgr * getStorageMgrForTableKey(const ChunkKey &table_key) const

+ Here is the call graph for this function:

void PersistentStorageMgr::free ( AbstractBuffer buffer)
override

Definition at line 172 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

172  {
173  global_file_mgr_->free(buffer);
174 }
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
size_t PersistentStorageMgr::getAllocated ( )
override

Definition at line 152 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

152  {
153  return global_file_mgr_->getAllocated();
154 }
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
AbstractBuffer * PersistentStorageMgr::getBuffer ( const ChunkKey chunk_key,
const size_t  num_bytes 
)
override

Definition at line 73 of file PersistentStorageMgr.cpp.

References getStorageMgrForTableKey().

74  {
75  return getStorageMgrForTableKey(chunk_key)->getBuffer(chunk_key, num_bytes);
76 }
AbstractBufferMgr * getStorageMgrForTableKey(const ChunkKey &table_key) const

+ Here is the call graph for this function:

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

Definition at line 107 of file PersistentStorageMgr.cpp.

References CHECK, foreign_storage::ForeignStorageMgr::createDataWrapperIfNotExists(), disk_cache_, getForeignStorageMgr(), getStorageMgrForTableKey(), has_table_prefix(), isChunkPrefixCacheable(), and isForeignStorage().

109  {
110  CHECK(has_table_prefix(keyPrefix));
111  // If the disk has any cached metadata for a prefix then it is guaranteed to have all
112  // metadata for that table, so we can return a complete set. If it has no metadata,
113  // then it may be that the table has no data, or that it's just not cached, so we need
114  // to go to storage to check.
115  if (isChunkPrefixCacheable(keyPrefix)) {
116  if (disk_cache_->hasCachedMetadataForKeyPrefix(keyPrefix)) {
117  disk_cache_->getCachedMetadataVecForKeyPrefix(chunk_metadata, keyPrefix);
118  if (isForeignStorage(keyPrefix)) {
120  }
121  return;
122  }
123  getStorageMgrForTableKey(keyPrefix)->getChunkMetadataVecForKeyPrefix(chunk_metadata,
124  keyPrefix);
125  disk_cache_->cacheMetadataVec(chunk_metadata);
126  } else {
127  getStorageMgrForTableKey(keyPrefix)->getChunkMetadataVecForKeyPrefix(chunk_metadata,
128  keyPrefix);
129  }
130 }
virtual bool createDataWrapperIfNotExists(const ChunkKey &chunk_key)
foreign_storage::ForeignStorageMgr * getForeignStorageMgr() const
bool isForeignStorage(const ChunkKey &chunk_key) const
bool has_table_prefix(const ChunkKey &key)
Definition: types.h:49
bool isChunkPrefixCacheable(const ChunkKey &chunk_prefix) const
std::unique_ptr< foreign_storage::ForeignStorageCache > disk_cache_
#define CHECK(condition)
Definition: Logger.h:206
AbstractBufferMgr * getStorageMgrForTableKey(const ChunkKey &table_key) const

+ Here is the call graph for this function:

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

Definition at line 233 of file PersistentStorageMgr.cpp.

References disk_cache_.

233  {
234  return disk_cache_ ? disk_cache_.get() : nullptr;
235 }
std::unique_ptr< foreign_storage::ForeignStorageCache > disk_cache_
const File_Namespace::DiskCacheConfig PersistentStorageMgr::getDiskCacheConfig ( ) const
inline

Definition at line 71 of file PersistentStorageMgr.h.

71  {
72  return disk_cache_config_;
73  }
File_Namespace::DiskCacheConfig disk_cache_config_
const std::shared_ptr<ForeignStorageInterface> PersistentStorageMgr::getForeignStorageInterface ( ) const
inline

Definition at line 74 of file PersistentStorageMgr.h.

75  {
76  return fsi_;
77  }
std::shared_ptr< ForeignStorageInterface > fsi_
foreign_storage::ForeignStorageMgr * PersistentStorageMgr::getForeignStorageMgr ( ) const

Definition at line 229 of file PersistentStorageMgr.cpp.

References foreign_storage_mgr_.

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

229  {
230  return foreign_storage_mgr_.get();
231 }
std::unique_ptr< foreign_storage::ForeignStorageMgr > foreign_storage_mgr_

+ Here is the caller graph for this function:

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

Definition at line 188 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

188  {
189  return global_file_mgr_.get();
190 }
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
size_t PersistentStorageMgr::getInUseSize ( )
override

Definition at line 148 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

148  {
149  return global_file_mgr_->getInUseSize();
150 }
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
size_t PersistentStorageMgr::getMaxSize ( )
override

Definition at line 144 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

144  {
145  return global_file_mgr_->getMaxSize();
146 }
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
MgrType PersistentStorageMgr::getMgrType ( )
override

Definition at line 176 of file PersistentStorageMgr.cpp.

176  {
177  return PERSISTENT_STORAGE_MGR;
178 }
size_t PersistentStorageMgr::getNumChunks ( )
override

Definition at line 184 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

184  {
185  return global_file_mgr_->getNumChunks();
186 }
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
AbstractBufferMgr * PersistentStorageMgr::getStorageMgrForTableKey ( const ChunkKey table_key) const
protected

Definition at line 220 of file PersistentStorageMgr.cpp.

References foreign_storage_mgr_, global_file_mgr_, and isForeignStorage().

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

221  {
222  if (isForeignStorage(table_key)) {
223  return foreign_storage_mgr_.get();
224  } else {
225  return global_file_mgr_.get();
226  }
227 }
bool isForeignStorage(const ChunkKey &chunk_key) const
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
std::unique_ptr< foreign_storage::ForeignStorageMgr > foreign_storage_mgr_

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

std::string PersistentStorageMgr::getStringMgrType ( )
override

Definition at line 180 of file PersistentStorageMgr.cpp.

180  {
181  return ToString(PERSISTENT_STORAGE_MGR);
182 }
bool PersistentStorageMgr::isAllocationCapped ( )
override

Definition at line 156 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

156  {
157  return global_file_mgr_->isAllocationCapped();
158 }
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
bool PersistentStorageMgr::isBufferOnDevice ( const ChunkKey chunk_key)
override

Definition at line 132 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

132  {
133  return global_file_mgr_->isBufferOnDevice(chunk_key);
134 }
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
bool PersistentStorageMgr::isChunkPrefixCacheable ( const ChunkKey chunk_prefix) const
protected

Definition at line 237 of file PersistentStorageMgr.cpp.

References CHECK, CHUNK_KEY_DB_IDX, CHUNK_KEY_TABLE_IDX, disk_cache_config_, fsi_, has_table_prefix(), File_Namespace::DiskCacheConfig::isEnabledForFSI(), File_Namespace::DiskCacheConfig::isEnabledForMutableTables(), and isForeignStorage().

Referenced by MutableCachePersistentStorageMgr::createBuffer(), fetchBuffer(), getChunkMetadataVecForKeyPrefix(), and removeTableRelatedDS().

237  {
238  CHECK(has_table_prefix(chunk_prefix));
239  // If this is an Arrow FSI table then we can't cache it.
240  if (fsi_->lookupBufferManager(chunk_prefix[CHUNK_KEY_DB_IDX],
241  chunk_prefix[CHUNK_KEY_TABLE_IDX])) {
242  return false;
243  }
245  !isForeignStorage(chunk_prefix)) ||
247 }
#define CHUNK_KEY_DB_IDX
Definition: types.h:39
std::shared_ptr< ForeignStorageInterface > fsi_
bool isForeignStorage(const ChunkKey &chunk_key) const
#define CHUNK_KEY_TABLE_IDX
Definition: types.h:40
bool has_table_prefix(const ChunkKey &key)
Definition: types.h:49
File_Namespace::DiskCacheConfig disk_cache_config_
#define CHECK(condition)
Definition: Logger.h:206

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

Definition at line 200 of file PersistentStorageMgr.cpp.

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

Referenced by MutableCachePersistentStorageMgr::deleteBuffer(), fetchBuffer(), getChunkMetadataVecForKeyPrefix(), getStorageMgrForTableKey(), and isChunkPrefixCacheable().

200  {
201  CHECK(has_table_prefix(chunk_key));
202  auto db_id = chunk_key[CHUNK_KEY_DB_IDX];
203  auto table_id = chunk_key[CHUNK_KEY_TABLE_IDX];
204  auto catalog = Catalog_Namespace::SysCatalog::instance().getCatalog(db_id);
205 
206  // if catalog doesnt exist at this point we must be in an old migration.
207  // Old migration can not, at this point 5.5.1, be using foreign storage
208  // so this hack is to avoid the crash, when migrating old
209  // catalogs that have not been upgraded over time due to issue
210  // [BE-5728]
211  if (!catalog) {
212  return false;
213  }
214 
215  auto table = catalog->getMetadataForTableImpl(table_id, false);
216  CHECK(table);
217  return table->storageType == StorageType::FOREIGN_TABLE;
218 }
#define CHUNK_KEY_DB_IDX
Definition: types.h:39
static SysCatalog & instance()
Definition: SysCatalog.h:292
#define CHUNK_KEY_TABLE_IDX
Definition: types.h:40
bool has_table_prefix(const ChunkKey &key)
Definition: types.h:49
std::shared_ptr< Catalog > getCatalog(const std::string &dbName)
#define CHECK(condition)
Definition: Logger.h:206
static constexpr char const * 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 136 of file PersistentStorageMgr.cpp.

References global_file_mgr_.

136  {
137  return global_file_mgr_->printSlabs();
138 }
std::unique_ptr< File_Namespace::GlobalFileMgr > global_file_mgr_
AbstractBuffer * PersistentStorageMgr::putBuffer ( const ChunkKey chunk_key,
AbstractBuffer source_buffer,
const size_t  num_bytes 
)
override

Definition at line 100 of file PersistentStorageMgr.cpp.

References getStorageMgrForTableKey().

Referenced by MutableCachePersistentStorageMgr::putBuffer().

102  {
103  return getStorageMgrForTableKey(chunk_key)->putBuffer(
104  chunk_key, source_buffer, num_bytes);
105 }
AbstractBufferMgr * getStorageMgrForTableKey(const ChunkKey &table_key) const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

int PersistentStorageMgr::recoverDataWrapperIfCachedAndGetHighestFragId ( const ChunkKey table_key)
protected
void PersistentStorageMgr::removeTableRelatedDS ( const int  db_id,
const int  table_id 
)
override

Definition at line 192 of file PersistentStorageMgr.cpp.

References disk_cache_, getStorageMgrForTableKey(), and isChunkPrefixCacheable().

Referenced by MutableCachePersistentStorageMgr::removeTableRelatedDS().

192  {
193  const ChunkKey table_key{db_id, table_id};
194  if (isChunkPrefixCacheable(table_key)) {
195  disk_cache_->clearForTablePrefix(table_key);
196  }
197  getStorageMgrForTableKey(table_key)->removeTableRelatedDS(db_id, table_id);
198 }
std::vector< int > ChunkKey
Definition: types.h:37
bool isChunkPrefixCacheable(const ChunkKey &chunk_prefix) const
std::unique_ptr< foreign_storage::ForeignStorageCache > disk_cache_
AbstractBufferMgr * getStorageMgrForTableKey(const ChunkKey &table_key) const

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Member Data Documentation

std::unique_ptr<foreign_storage::ForeignStorageMgr> PersistentStorageMgr::foreign_storage_mgr_
protected
std::shared_ptr<ForeignStorageInterface> PersistentStorageMgr::fsi_
protected

Definition at line 89 of file PersistentStorageMgr.h.

Referenced by isChunkPrefixCacheable(), and PersistentStorageMgr().


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