#include <GlobalFileMgr.h>

Inheritance diagram for File_Namespace::GlobalFileMgr:

Collaboration diagram for File_Namespace::GlobalFileMgr:

Public Member Functions
	GlobalFileMgr (const int deviceId, std::string basePath=".", const size_t num_reader_threads=0, const size_t defaultPageSize=2097152)
	Constructor. More...

AbstractBuffer *	createBuffer (const ChunkKey &key, size_t pageSize=0, const size_t numBytes=0) override
	Creates a chunk with the specified key and page size. More...

bool	isBufferOnDevice (const ChunkKey &key) override

void	deleteBuffer (const ChunkKey &key, const bool purge=true) override
	Deletes the chunk with the specified key. More...

void	deleteBuffersWithPrefix (const ChunkKey &keyPrefix, const bool purge=true) override

AbstractBuffer *	getBuffer (const ChunkKey &key, const size_t numBytes=0) override
	Returns the a pointer to the chunk with the specified key. More...

void	fetchBuffer (const ChunkKey &key, AbstractBuffer *destBuffer, const size_t numBytes) override

AbstractBuffer *	putBuffer (const ChunkKey &key, AbstractBuffer *d, const size_t numBytes=0) override
	Puts the contents of d into the Chunk with the given key. More...

AbstractBuffer *	alloc (const size_t numBytes) override

void	free (AbstractBuffer *buffer) override

MgrType	getMgrType () override

std::string	getStringMgrType () override

std::string	printSlabs () override

void	clearSlabs () override

size_t	getMaxSize () override

size_t	getInUseSize () override

size_t	getAllocated () override

bool	isAllocationCapped () override

void	init ()

void	getChunkMetadataVecForKeyPrefix (ChunkMetadataVector &chunkMetadataVec, const ChunkKey &keyPrefix) override

void	checkpoint () override
	Fsyncs data files, writes out epoch and fsyncs that. More...

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

size_t	getNumReaderThreads ()
	Returns number of threads defined by parameter num-reader-threads which should be used during initial load and consequent read of data. More...

size_t	getNumChunks () override

AbstractBufferMgr *	getFileMgr (const int db_id, const int tb_id)

AbstractBufferMgr *	getFileMgr (const ChunkKey &key)

std::string	getBasePath () const

size_t	getDefaultPageSize () const

void	writeFileMgrData (FileMgr *fileMgr=0)

int	getDBVersion () const

bool	getDBConvert () const

void	setDBConvert (bool val)

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

void	setTableEpoch (const int db_id, const int tb_id, const int start_epoch)

size_t	getTableEpoch (const int db_id, const int tb_id)

std::shared_ptr< FileMgr >	getSharedFileMgr (const int db_id, const int table_id)

void	setFileMgr (const int db_id, const int table_id, std::shared_ptr< FileMgr > file_mgr)

Private Member Functions
AbstractBufferMgr *	findFileMgr (const int db_id, const int tb_id)

void	deleteFileMgr (const int db_id, const int tb_id)

Private Attributes
std::string	basePath_

size_t	num_reader_threads_
	The OS file system path containing the files. More...

int	epoch_
	number of threads used when loading data More...

size_t	defaultPageSize_

int	mapd_db_version_
	default page size, used to set FileMgr defaultPageSize_ More...

bool	dbConvert_

std::map< std::pair< int, int > , std::shared_ptr< FileMgr > >	ownedFileMgrs_

std::map< std::pair< int, int > , AbstractBufferMgr * >	allFileMgrs_

mapd_shared_mutex	fileMgrs_mutex_

Detailed Description

Definition at line 47 of file GlobalFileMgr.h.

Constructor & Destructor Documentation

File_Namespace::GlobalFileMgr::GlobalFileMgr	(	const int	deviceId,
		std::string	basePath = `"."`,
		const size_t	num_reader_threads = `0`,
		const size_t	defaultPageSize = `2097152`
	)

Constructor.

Definition at line 41 of file GlobalFileMgr.cpp.

References dbConvert_, init(), and mapd_db_version_.

     : AbstractBufferMgr(deviceId)
     , basePath_(basePath)
     , num_reader_threads_(num_reader_threads)
     , epoch_(-1)
     ,  // set the default epoch for all tables corresponding to the time of
        // last checkpoint
     defaultPageSize_(defaultPageSize) {
   mapd_db_version_ =
       1;  // DS changes triggered by individual FileMgr per table project (release 2.1.0)
   dbConvert_ = false;
   init();
 }

Here is the call graph for this function:

Member Function Documentation

AbstractBuffer* File_Namespace::GlobalFileMgr::alloc ( const size_t numBytes )

inlineoverride

Definition at line 102 of file GlobalFileMgr.h.

References logger::FATAL, and LOG.

                                                         {
     LOG(FATAL) << "Operation not supported";
     return nullptr;  // satisfy return-type warning
   }

void File_Namespace::GlobalFileMgr::checkpoint ( )

override

Fsyncs data files, writes out epoch and fsyncs that.

Definition at line 75 of file GlobalFileMgr.cpp.

References allFileMgrs_, and fileMgrs_mutex_.

                                {
   mapd_unique_lock<mapd_shared_mutex> write_lock(fileMgrs_mutex_);
   for (auto fileMgrsIt = allFileMgrs_.begin(); fileMgrsIt != allFileMgrs_.end();
        ++fileMgrsIt) {
     fileMgrsIt->second->checkpoint();
   }
 }

void File_Namespace::GlobalFileMgr::checkpoint	(	const int	db_id,
		const int	tb_id
	)

override

Definition at line 83 of file GlobalFileMgr.cpp.

References getFileMgr().

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

Here is the call graph for this function:

void File_Namespace::GlobalFileMgr::clearSlabs ( )

inlineoverride

Definition at line 112 of file GlobalFileMgr.h.

112 { /* noop */

113 }

AbstractBuffer* File_Namespace::GlobalFileMgr::createBuffer	(	const ChunkKey &	key,
		size_t	pageSize = `0`,
		const size_t	numBytes = `0`
	)

inlineoverride

Creates a chunk with the specified key and page size.

Definition at line 57 of file GlobalFileMgr.h.

                                                                    {
     return getFileMgr(key)->createBuffer(key, pageSize, numBytes);
   }

void File_Namespace::GlobalFileMgr::deleteBuffer	(	const ChunkKey &	key,
		const bool	purge = `true`
	)

inlineoverride

Deletes the chunk with the specified key.

Definition at line 71 of file GlobalFileMgr.h.

                                                                            {
     return getFileMgr(key)->deleteBuffer(key, purge);
   }

void File_Namespace::GlobalFileMgr::deleteBuffersWithPrefix	(	const ChunkKey &	keyPrefix,
		const bool	purge = `true`
	)

override

Definition at line 98 of file GlobalFileMgr.cpp.

References getFileMgr().

                                                                                        {
   /* keyPrefix[0] can be -1 only for gpu or cpu buffers but not for FileMgr.
    * There is no assert here, as GlobalFileMgr is being called with -1 value as well in
    * the same loop with other buffers. So the case of -1 will just be ignored, as nothing
    * needs to be done.
    */
   if (keyPrefix[0] != -1) {
     return getFileMgr(keyPrefix)->deleteBuffersWithPrefix(keyPrefix, purge);
   }
 }

Here is the call graph for this function:

void File_Namespace::GlobalFileMgr::deleteFileMgr	(	const int	db_id,
		const int	tb_id
	)

private

Definition at line 119 of file GlobalFileMgr.cpp.

References allFileMgrs_, and ownedFileMgrs_.

Referenced by removeTableRelatedDS(), and setTableEpoch().

                                                                   {
   // NOTE: only call this private function after locking is already in place
   const auto file_mgr_key = std::make_pair(db_id, tb_id);
   if (auto it = ownedFileMgrs_.find(file_mgr_key); it != ownedFileMgrs_.end()) {
     ownedFileMgrs_.erase(it);
   }
   if (auto it = allFileMgrs_.find(file_mgr_key); it != allFileMgrs_.end()) {
     allFileMgrs_.erase(it);
   }
 }

Here is the caller graph for this function:

void File_Namespace::GlobalFileMgr::fetchBuffer	(	const ChunkKey &	key,
		AbstractBuffer *	destBuffer,
		const size_t	numBytes
	)

inlineoverride

Definition at line 83 of file GlobalFileMgr.h.

                                                    {
     return getFileMgr(key)->fetchBuffer(key, destBuffer, numBytes);
   }

AbstractBufferMgr * File_Namespace::GlobalFileMgr::findFileMgr	(	const int	db_id,
		const int	tb_id
	)

private

Definition at line 109 of file GlobalFileMgr.cpp.

References allFileMgrs_.

Referenced by getFileMgr(), and removeTableRelatedDS().

                                                                               {
   // NOTE: only call this private function after locking is already in place
   AbstractBufferMgr* fm = nullptr;
   const auto file_mgr_key = std::make_pair(db_id, tb_id);
   if (auto it = allFileMgrs_.find(file_mgr_key); it != allFileMgrs_.end()) {
     fm = it->second;
   }
   return fm;
 }

Here is the caller graph for this function:

void File_Namespace::GlobalFileMgr::free ( AbstractBuffer * buffer )

inlineoverride

Definition at line 107 of file GlobalFileMgr.h.

References logger::FATAL, and LOG.

107 { LOG(FATAL) << "Operation not supported"; }

LOG

#define LOG(tag)

Definition: Logger.h:188

logger::FATAL

Definition: Logger.h:81

size_t File_Namespace::GlobalFileMgr::getAllocated ( )

inlineoverride

Definition at line 116 of file GlobalFileMgr.h.

116 { return 0; }

std::string File_Namespace::GlobalFileMgr::getBasePath ( ) const

inline

Definition at line 152 of file GlobalFileMgr.h.

Referenced by anonymous_namespace{TableArchiver.cpp}::abs_path(), File_Namespace::FileMgr::FileMgr(), and File_Namespace::FileMgr::init().

152 { return basePath_; }

File_Namespace::GlobalFileMgr::basePath_

std::string basePath_

Definition: GlobalFileMgr.h:172

Here is the caller graph for this function:

AbstractBuffer* File_Namespace::GlobalFileMgr::getBuffer	(	const ChunkKey &	key,
		const size_t	numBytes = `0`
	)

inlineoverride

Returns the a pointer to the chunk with the specified key.

Definition at line 79 of file GlobalFileMgr.h.

                                                                                      {
     return getFileMgr(key)->getBuffer(key, numBytes);
   }

void File_Namespace::GlobalFileMgr::getChunkMetadataVecForKeyPrefix	(	ChunkMetadataVector &	chunkMetadataVec,
		const ChunkKey &	keyPrefix
	)

inlineoverride

Definition at line 121 of file GlobalFileMgr.h.

                                                                            {
     return getFileMgr(keyPrefix)->getChunkMetadataVecForKeyPrefix(chunkMetadataVec,
                                                                   keyPrefix);
   }

bool File_Namespace::GlobalFileMgr::getDBConvert ( ) const

inline

Definition at line 158 of file GlobalFileMgr.h.

Referenced by File_Namespace::FileMgr::getDBConvert().

158 { return dbConvert_; }

File_Namespace::GlobalFileMgr::dbConvert_

bool dbConvert_

Definition: GlobalFileMgr.h:187

Here is the caller graph for this function:

int File_Namespace::GlobalFileMgr::getDBVersion ( ) const

inline

Definition at line 157 of file GlobalFileMgr.h.

Referenced by File_Namespace::FileMgr::getDBVersion().

157 { return mapd_db_version_; }

File_Namespace::GlobalFileMgr::mapd_db_version_

int mapd_db_version_

default page size, used to set FileMgr defaultPageSize_

Definition: GlobalFileMgr.h:181

Here is the caller graph for this function:

size_t File_Namespace::GlobalFileMgr::getDefaultPageSize ( ) const

inline

Definition at line 153 of file GlobalFileMgr.h.

153 { return defaultPageSize_; }

File_Namespace::GlobalFileMgr::defaultPageSize_

size_t defaultPageSize_

Definition: GlobalFileMgr.h:178

AbstractBufferMgr * File_Namespace::GlobalFileMgr::getFileMgr	(	const int	db_id,
		const int	tb_id
	)

Definition at line 130 of file GlobalFileMgr.cpp.

References allFileMgrs_, CHECK, defaultPageSize_, epoch_, fileMgrs_mutex_, findFileMgr(), ForeignStorageInterface::lookupBufferManager(), num_reader_threads_, and ownedFileMgrs_.

Referenced by checkpoint(), deleteBuffersWithPrefix(), foreign_storage::ForeignStorageCache::getCacheDirectoryForTablePrefix(), getTableEpoch(), and File_Namespace::FileMgr::init().

                                                                              {
   {  // check if FileMgr already exists for (db_id, tb_id)
     mapd_shared_lock<mapd_shared_mutex> read_lock(fileMgrs_mutex_);
     AbstractBufferMgr* fm = findFileMgr(db_id, tb_id);
     if (fm) {
       return fm;
     }
   }
 
   {  // create new FileMgr for (db_id, tb_id)
     mapd_unique_lock<mapd_shared_mutex> write_lock(fileMgrs_mutex_);
     AbstractBufferMgr* fm = findFileMgr(db_id, tb_id);
     if (fm) {
       return fm;  // mgr was added between the read lock and the write lock
     }
     const auto file_mgr_key = std::make_pair(db_id, tb_id);
     const auto foreign_buffer_manager =
         ForeignStorageInterface::lookupBufferManager(db_id, tb_id);
     if (foreign_buffer_manager) {
       CHECK(allFileMgrs_.insert(std::make_pair(file_mgr_key, foreign_buffer_manager))
                 .second);
       return foreign_buffer_manager;
     } else {
       auto s = std::make_shared<FileMgr>(
           0, this, file_mgr_key, num_reader_threads_, epoch_, defaultPageSize_);
       CHECK(ownedFileMgrs_.insert(std::make_pair(file_mgr_key, s)).second);
       CHECK(allFileMgrs_.insert(std::make_pair(file_mgr_key, s.get())).second);
       return s.get();
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AbstractBufferMgr* File_Namespace::GlobalFileMgr::getFileMgr ( const ChunkKey & key )

inline

Definition at line 148 of file GlobalFileMgr.h.

                                                      {
     return getFileMgr(key[0], key[1]);
   }

size_t File_Namespace::GlobalFileMgr::getInUseSize ( )

inlineoverride

Definition at line 115 of file GlobalFileMgr.h.

115 { return 0; }

size_t File_Namespace::GlobalFileMgr::getMaxSize ( )

inlineoverride

Definition at line 114 of file GlobalFileMgr.h.

114 { return 0; }

MgrType File_Namespace::GlobalFileMgr::getMgrType ( )

inlineoverride

Definition at line 109 of file GlobalFileMgr.h.

109 { return GLOBAL_FILE_MGR; };

size_t File_Namespace::GlobalFileMgr::getNumChunks ( )

override

Definition at line 87 of file GlobalFileMgr.cpp.

References allFileMgrs_, and fileMgrs_mutex_.

                                    {
   mapd_shared_lock<mapd_shared_mutex> read_lock(fileMgrs_mutex_);
   size_t num_chunks = 0;
   for (auto fileMgrsIt = allFileMgrs_.begin(); fileMgrsIt != allFileMgrs_.end();
        ++fileMgrsIt) {
     num_chunks += fileMgrsIt->second->getNumChunks();
   }
 
   return num_chunks;
 }

size_t File_Namespace::GlobalFileMgr::getNumReaderThreads ( )

inline

Returns number of threads defined by parameter num-reader-threads which should be used during initial load and consequent read of data.

Definition at line 138 of file GlobalFileMgr.h.

138 { return num_reader_threads_; }

File_Namespace::GlobalFileMgr::num_reader_threads_

size_t num_reader_threads_

The OS file system path containing the files.

Definition: GlobalFileMgr.h:173

std::shared_ptr< FileMgr > File_Namespace::GlobalFileMgr::getSharedFileMgr	(	const int	db_id,
		const int	table_id
	)

Definition at line 163 of file GlobalFileMgr.cpp.

References ownedFileMgrs_.

                                                                              {
   const auto table_key = std::make_pair(db_id, table_id);
   if (ownedFileMgrs_.find(table_key) == ownedFileMgrs_.end()) {
     return nullptr;
   }
   return ownedFileMgrs_[table_key];
 }

std::string File_Namespace::GlobalFileMgr::getStringMgrType ( )

inlineoverride

Definition at line 110 of file GlobalFileMgr.h.

110 { return ToString(GLOBAL_FILE_MGR); }

size_t File_Namespace::GlobalFileMgr::getTableEpoch	(	const int	db_id,
		const int	tb_id
	)

Definition at line 234 of file GlobalFileMgr.cpp.

References CHECK, and getFileMgr().

                                                                     {
   auto fm = dynamic_cast<FileMgr*>(getFileMgr(db_id, tb_id));
   CHECK(fm);
   return fm->epoch_;
 }

Here is the call graph for this function:

void File_Namespace::GlobalFileMgr::init ( )

Definition at line 58 of file GlobalFileMgr.cpp.

References basePath_, logger::FATAL, and LOG.

Referenced by GlobalFileMgr().

                          {
   // check if basePath_ already exists, and if not create one
   boost::filesystem::path path(basePath_);
   if (basePath_.size() > 0 && basePath_[basePath_.size() - 1] != '/') {
     basePath_.push_back('/');
   }
   if (boost::filesystem::exists(path)) {
     if (!boost::filesystem::is_directory(path)) {
       LOG(FATAL) << "Specified path is not a directory.";
     }
   } else {  // data directory does not exist
     if (!boost::filesystem::create_directory(path)) {
       LOG(FATAL) << "Could not create data directory";
     }
   }
 }

Here is the caller graph for this function:

bool File_Namespace::GlobalFileMgr::isAllocationCapped ( )

inlineoverride

Definition at line 117 of file GlobalFileMgr.h.

117 { return false; }

bool File_Namespace::GlobalFileMgr::isBufferOnDevice ( const ChunkKey & key )

inlineoverride

Definition at line 63 of file GlobalFileMgr.h.

                                                       {
     return getFileMgr(key)->isBufferOnDevice(key);
   }

std::string File_Namespace::GlobalFileMgr::printSlabs ( )

inlineoverride

Definition at line 111 of file GlobalFileMgr.h.

111 { return "Not Implemented"; }

AbstractBuffer* File_Namespace::GlobalFileMgr::putBuffer	(	const ChunkKey &	key,
		AbstractBuffer *	d,
		const size_t	numBytes = `0`
	)

inlineoverride

Puts the contents of d into the Chunk with the given key.

Parameters

key	- Unique identifier for a Chunk.
d	- An object representing the source data for the Chunk.

Returns: AbstractBuffer*

Definition at line 95 of file GlobalFileMgr.h.

                                                                 {
     return getFileMgr(key)->putBuffer(key, d, numBytes);
   }

void File_Namespace::GlobalFileMgr::removeTableRelatedDS	(	const int	db_id,
		const int	tb_id
	)

override

Definition at line 199 of file GlobalFileMgr.cpp.

References File_Namespace::FileMgr::closeRemovePhysical(), deleteFileMgr(), fileMgrs_mutex_, and findFileMgr().

                                                                          {
   mapd_unique_lock<mapd_shared_mutex> write_lock(fileMgrs_mutex_);
   auto fm = dynamic_cast<File_Namespace::FileMgr*>(findFileMgr(db_id, tb_id));
   if (fm) {
     fm->closeRemovePhysical();
   } else {
     // fileMgr has not been initialized so there is no need to
     // spend the time initializing
     // initialize just enough to have to rename
     const auto file_mgr_key = std::make_pair(db_id, tb_id);
     auto u = std::make_unique<FileMgr>(0, this, file_mgr_key, true);
     u->closeRemovePhysical();
   }
   // remove table related in-memory DS only if directory was removed successfully
 
   deleteFileMgr(db_id, tb_id);
 }

Here is the call graph for this function:

void File_Namespace::GlobalFileMgr::setDBConvert ( bool val )

inline

Definition at line 159 of file GlobalFileMgr.h.

159 { dbConvert_ = val; }

File_Namespace::GlobalFileMgr::dbConvert_

bool dbConvert_

Definition: GlobalFileMgr.h:187

void File_Namespace::GlobalFileMgr::setFileMgr	(	const int	db_id,
		const int	table_id,
		std::shared_ptr< FileMgr >	file_mgr
	)

Definition at line 173 of file GlobalFileMgr.cpp.

References allFileMgrs_, and ownedFileMgrs_.

                                                                 {
   allFileMgrs_[{db_id, table_id}] = file_mgr.get();
   ownedFileMgrs_[{db_id, table_id}] = file_mgr;
 }

void File_Namespace::GlobalFileMgr::setTableEpoch	(	const int	db_id,
		const int	tb_id,
		const int	start_epoch
	)

Definition at line 217 of file GlobalFileMgr.cpp.

References defaultPageSize_, deleteFileMgr(), fileMgrs_mutex_, and num_reader_threads_.

                                                          {
   mapd_unique_lock<mapd_shared_mutex> write_lock(fileMgrs_mutex_);
   const auto file_mgr_key = std::make_pair(db_id, tb_id);
   // this is where the real rollback of any data ahead of the currently set epoch is
   // performed
   auto u = std::make_unique<FileMgr>(
       0, this, file_mgr_key, num_reader_threads_, start_epoch, defaultPageSize_);
   u->setEpoch(start_epoch - 1);
   // remove the dummy one we built
   u.reset();
 
   // see if one exists currently, and remove it
   deleteFileMgr(db_id, tb_id);
 }

Here is the call graph for this function:

void File_Namespace::GlobalFileMgr::writeFileMgrData ( FileMgr * fileMgr = 0 )

Definition at line 180 of file GlobalFileMgr.cpp.

References allFileMgrs_, CHECK, File_Namespace::FileMgr::chunkIndex_, and fileMgrs_mutex_.

                       {  // this function is not used, keep it for now for future needs
   mapd_shared_lock<mapd_shared_mutex> read_lock(fileMgrs_mutex_);
   for (auto fileMgrIt = allFileMgrs_.begin(); fileMgrIt != allFileMgrs_.end();
        fileMgrIt++) {
     FileMgr* fm = dynamic_cast<FileMgr*>(fileMgrIt->second);
     CHECK(fm);
     if ((fileMgr != 0) && (fileMgr != fm)) {
       continue;
     }
     for (auto chunkIt = fm->chunkIndex_.begin(); chunkIt != fm->chunkIndex_.end();
          chunkIt++) {
       chunkIt->second->write((int8_t*)chunkIt->second, chunkIt->second->size(), 0);
       // chunkIt->second->write((int8_t*)chunkIt->second, chunkIt->second->size(), 0,
       // CPU_LEVEL, -1);
     }
   }
 }

Member Data Documentation

std::map<std::pair<int, int>, AbstractBufferMgr*> File_Namespace::GlobalFileMgr::allFileMgrs_

private

Definition at line 191 of file GlobalFileMgr.h.

Referenced by checkpoint(), deleteFileMgr(), findFileMgr(), getFileMgr(), getNumChunks(), setFileMgr(), and writeFileMgrData().

std::string File_Namespace::GlobalFileMgr::basePath_

private

Definition at line 172 of file GlobalFileMgr.h.

Referenced by init().

bool File_Namespace::GlobalFileMgr::dbConvert_

private

DB version for DataMgr DS and corresponding file buffer read/write code

Definition at line 187 of file GlobalFileMgr.h.

Referenced by GlobalFileMgr().

size_t File_Namespace::GlobalFileMgr::defaultPageSize_

private

Definition at line 178 of file GlobalFileMgr.h.

Referenced by getFileMgr(), and setTableEpoch().

int File_Namespace::GlobalFileMgr::epoch_

private

number of threads used when loading data

Definition at line 174 of file GlobalFileMgr.h.

Referenced by getFileMgr().

mapd_shared_mutex File_Namespace::GlobalFileMgr::fileMgrs_mutex_

private

Definition at line 193 of file GlobalFileMgr.h.

Referenced by checkpoint(), getFileMgr(), getNumChunks(), removeTableRelatedDS(), setTableEpoch(), and writeFileMgrData().

int File_Namespace::GlobalFileMgr::mapd_db_version_

private

default page size, used to set FileMgr defaultPageSize_

Definition at line 181 of file GlobalFileMgr.h.

Referenced by GlobalFileMgr().

size_t File_Namespace::GlobalFileMgr::num_reader_threads_

private

The OS file system path containing the files.

Definition at line 173 of file GlobalFileMgr.h.

Referenced by getFileMgr(), and setTableEpoch().

std::map<std::pair<int, int>, std::shared_ptr<FileMgr> > File_Namespace::GlobalFileMgr::ownedFileMgrs_

private

true if conversion should be done between different "mapd_db_version_"

Definition at line 190 of file GlobalFileMgr.h.

Referenced by deleteFileMgr(), getFileMgr(), getSharedFileMgr(), and setFileMgr().

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

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation