#include <Database.h>

Inheritance diagram for Database:

Collaboration diagram for Database:

Classes
struct	Specification

Public Member Functions
	Database (SessionTool &session, const std::string &name, const Specification::NameType nameType)
	Constructor.
	~Database ()
	Destructor.
void	connectForRead ()
	Connects explicitly to the database for read operations.
void *	readObject (const Token &token, void *object=0)
	Reads an object given a token.
void	connectForWrite ()
	Connects explicitly to the database for write/update operations.
Token *	writeObject (const std::string &containerName, long minorTechnology, const void *object, const RootType &type)
	Writes an object and returns a token.
void	disconnect ()
	Disconnects from the database.
Io::IoFlag	openMode () const
	Returns the opening mode. It can be used to check whether the database is connected.
const std::string &	fid ()
	Returns the file identifier of this database.
const std::string &	pfn ()
	Returns the physical file name of this database.
bool	setTechnology (long technology)
	Sets the technology identifier for this database.
std::vector< std::string >	containers ()
	Returns the names of the containers in this database.
Container *	containerHandle (const std::string &name)
	Returns a pointer to a container object. The user acquires ownership of that object.
pool::FileDescriptor *	fileDescriptor ()
bool	attributeOfType (const std::string &attributeName, void *data, const std::type_info &typeInfo, const std::string &option)
bool	setAttributeOfType (const std::string &attributeName, const void *data, const std::type_info &typeInfo, const std::string &option)
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Member Functions
bool	checkInRegistry ()
	Checks in the registry if the database handler already exists.
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
SessionTool &	m_session
	Reference to the session.
Gaudi::IFileCatalog &	m_catalog
	Reference to the file catalog.
Io::IoFlag	m_transactionType
	Transaction type (read/update).
DatabaseRegistry &	m_registry
	Reference to the database registry.
std::string	m_name
	The database name.
Specification::NameType	m_nameType
	The database name spacification.
long	m_technology
	The technology identifier of the database.
bool	m_technologySet
	Checks if the technology identifier has been set.
DatabaseHandler *	m_databaseHandler
	The underlying database handler.
Io::IoFlag	m_openMode
	Current open mode.
bool	m_alreadyConnected
	Flag indicating whether a connection has been already made once.
std::string	m_the_fid
	Other names used.
std::string	m_the_pfn
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

Definition at line 27 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

Constructor & Destructor Documentation

◆ Database()

Database::Database	(	SessionTool &	session,
		const std::string &	name,
		const Specification::NameType	nameType )

Constructor.

Definition at line 19 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

                                                          :
  AthMessaging("PoolSvc.Database"),                                                  
  m_session( session ),
  m_catalog( session.fileCatalog() ),
  m_transactionType( session.openMode() ),
  m_registry( session.registry() ),
  m_name( name ),
  m_nameType( nameType ),
  m_technology( 0 ),
  m_technologySet( false ),
  m_databaseHandler( 0 ),
  m_openMode( Io::INVALID ),
  m_alreadyConnected( false ),
  m_the_fid( "" ),
  m_the_pfn( "" )
{
  this->checkInRegistry();
}

◆ ~Database()

Database::~Database ( )

Destructor.

Definition at line 41 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

42{}

Member Function Documentation

◆ attributeOfType()

bool Database::attributeOfType	(	const std::string &	attributeName,
		void *	data,
		const std::type_info &	typeInfo,
		const std::string &	option )

Definition at line 362 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
  if ( ! m_databaseHandler ) return false;
  else return m_databaseHandler->attribute( attributeName, data, typeInfo, option );
}

◆ checkInRegistry()

bool Database::checkInRegistry ( )

private

Checks in the registry if the database handler already exists.

Definition at line 326 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
  // Check first if the database is already connected.
  switch( m_nameType ) {
  case Specification::PFN:
    m_databaseHandler = m_registry.lookupByPFN( m_name );
    break;
  case Specification::FID:
    m_databaseHandler = m_registry.lookupByFID( m_name );
    break;
  case Specification::LFN:
    m_databaseHandler = m_registry.lookupByLFN( m_name );
    break;
  default:
    throw std::runtime_error( "Only PFN, LFN and FID database types are currently supported (APR: \" Database::checkInRegistry \" from \" PersistencySvc \")" );
  };
  if ( m_databaseHandler ) {
    m_alreadyConnected = true;
    m_technology = m_databaseHandler->technology();
    m_openMode   = m_databaseHandler->accessMode();
    m_the_fid = m_name = m_databaseHandler->fid();
    m_the_pfn = m_databaseHandler->pfn();
    m_nameType = Specification::FID;
    return true;
  }
  else return false;
}

◆ connectForRead()

void Database::connectForRead ( )

Connects explicitly to the database for read operations.

Definition at line 46 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
  if( !m_databaseHandler && m_transactionType != Io::INVALID ) {
    // Check if the database is already connected
    if( !checkInRegistry() ) {
      // It is not. Connect !
      switch( m_nameType ) {
      case Specification::PFN:
        if ( this->fid().empty() ) {
          throw std::runtime_error( "PFN \"" + m_name + "\" is not existing (APR: \" Database::connectForRead \" from \" PersistencySvc \")" );
        }
        break;
 
      case Specification::FID:
        if ( this->pfn().empty() ) {
          throw std::runtime_error( "FID \"" + m_name + "\" is not existing in the catalog (APR: \" Database::connectForRead \" from \" PersistencySvc \")" );
        }
        break;
      case Specification::LFN:
        {
          std::string lfn = m_name;
          if ( this->fid().empty() ) {
            throw std::runtime_error( "LFN \"" + m_name + "\" is not existing in the catalog (APR: \" Database::connectForRead \" from \" PersistencySvc \")" );
          }
          this->connectForRead();
          m_registry.registerDatabaseHandler( m_databaseHandler, lfn );
        }
      return;
      break;
      default:
        throw std::runtime_error( "Unknown database name type (APR: \" Database::connectForRead \" from \" PersistencySvc \")" );
      };
 
      // Now we have all the usefull information to open the file.
      // Check the registry now that we have the FID (in case of ambiguous PFNs)
      m_databaseHandler = m_registry.lookupByFID( m_the_fid );
      if( !m_databaseHandler ) {
         // still no luck - make a new connection
         m_databaseHandler = m_session.microSessionManager( m_technology ).connect( m_transactionType, m_the_fid, m_the_pfn );
      }
      if( m_databaseHandler ) {
        m_openMode = Io::READ;
      }
      else {
        throw std::runtime_error( "Could not connect to the file (APR: \" Database::connectForRead \" from \" PersistencySvc \")" );
      }
    }
  }
}

◆ connectForWrite()

void Database::connectForWrite ( )

Connects explicitly to the database for write/update operations.

Definition at line 108 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
  if( !m_databaseHandler && m_transactionType != Io::INVALID ) {
    if ( m_transactionType != Io::WRITE && m_transactionType != Io::APPEND ) {
      throw std::runtime_error( "Could not open a database for write outside an update transaction. (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
    }
 
    if ( this->checkInRegistry() ) {
      if ( m_openMode == Io::READ ) {
        throw std::runtime_error( "Could not open a database for write that is already connected for read. (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
      }
    }
    else { // The database is not yet connected.
      bool dbRegistered = false;
      switch( m_nameType ) {
      case Specification::PFN:
        m_the_pfn = m_name;
        if ( this->fid().empty() ) {
      // Check if the technology is already set
      if( ! m_technologySet ) {
         throw std::runtime_error( "The back end technology has not been specified (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
      }
      // register in the catalog 
      pool::DbType dbType( m_technology );
      pool::DbType dbTypeMajor( dbType.majorType() );
      FileCatalogUtils::registerPFN( m_catalog, m_the_pfn.substr(0, m_the_pfn.find('?')), dbTypeMajor.storageName(), m_the_fid );
    ATH_MSG_DEBUG("registered PFN: " << m_the_pfn << " with FID:" << m_the_fid);
      dbRegistered = true;
        }
        break;
      case Specification::FID:
        m_the_fid = m_name;
        if ( this->pfn().empty() ) {
          throw std::runtime_error( "Could not find the FID \"" + m_name + "\" in the file catalog (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
        }
        break;
      case Specification::LFN:
        {
          std::string lfn = m_name;
          if ( this->fid().empty() ) {
            throw std::runtime_error( "Could not find the LFN \"" + m_name  + "\" in the file catalog (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
          }
          this->connectForWrite();
          m_registry.registerDatabaseHandler( m_databaseHandler, lfn );
        }
        return;
        break;
      default:
        throw std::runtime_error( "Unknown database name type (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
      };
 
      m_databaseHandler = m_session.microSessionManager( m_technology ).connect( m_transactionType, m_the_fid, m_the_pfn );
      if( !m_databaseHandler ) {
        if( dbRegistered ) {
          // creation failed, remove entry from the in-memory catalog
          m_catalog.deleteFID( m_the_fid );
        }
        throw std::runtime_error( "Could not connect to the file (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
      }
      m_openMode = m_transactionType == Io::WRITE ? Io::WRITE : Io::APPEND;
    } // Connection established
 
  } // Database handler retrieved
}

◆ containerHandle()

Container * Database::containerHandle ( const std::string & name )

Returns a pointer to a container object. The user acquires ownership of that object.

Definition at line 315 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
  Container* container = 0;
  if ( m_databaseHandler ) {
    container = m_databaseHandler->container( name );
  }
  return container;
}

◆ containers()

std::vector< std::string > Database::containers ( )

Returns the names of the containers in this database.

Definition at line 304 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
  std::vector< std::string > containers;
  if ( m_databaseHandler ) {
    containers = m_databaseHandler->containers();
  }
  return containers;
}

◆ disconnect()

void Database::disconnect ( )

Disconnects from the database.

Definition at line 188 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
  if ( m_databaseHandler ) {
    m_session.microSessionManager( m_technology ).disconnect( m_databaseHandler );
    m_openMode = Io::INVALID;
  }
}

◆ fid()

const std::string & Database::fid ( )

Returns the file identifier of this database.

Definition at line 205 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
  if ( m_databaseHandler ) return m_databaseHandler->fid();
  else {
    if ( m_nameType == Specification::FID ) return m_name;
    else if ( !m_the_fid.empty() ) return m_the_fid;
    else {
      if ( m_nameType == Specification::PFN ) {
         std::string technology;
         FileCatalogUtils::lookupFileByPFN( m_catalog, m_name.substr(0, m_name.find('?')), m_the_fid, technology );
         ATH_MSG_DEBUG("lookupPFN: " << m_name << " returned FID: '" << m_the_fid << "' tech=" << technology);
         if ( ! m_the_fid.empty() ) {
            if( technology.empty() ) {
               m_nameType = Specification::LFN;
               ATH_MSG_DEBUG("Retrying 'connect' using assumed PFN " << m_name << " as LFN (no tech found in PFC)" );
               return m_the_fid;
            }
            m_the_pfn = m_name;
            m_technology = pool::DbType::getType( technology ).majorType();
            m_alreadyConnected = true;
         }
         else {
           if( m_transactionType != Io::WRITE ) { // Fetch the FID from the db itself !
              if( !m_technologySet ) {
                 ATH_MSG_DEBUG("Opening database '" << m_name << "' with no technology set");
                 m_technology = pool::ROOT_StorageType.type();
                 m_technologySet = true;
              }
              m_the_fid = m_session.microSessionManager( m_technology ).fidForPfn( m_name );
              if( ! m_the_fid.empty() ) {
                 // sanity check - verify that the FID is not registered in PFC under a different name
                 std::string  pfn, tech;
                 FileCatalogUtils::getFirstPFN( m_catalog, m_the_fid, pfn, tech );
                 if( !pfn.empty() ) {
                    ATH_MSG_WARNING("Opening file '" << m_name << "' which is already registered in the Catalog as '" << pfn 
                                    <<"' (GUID " << m_the_fid << ") - this is not supported and may even lead to a crash!" );
                 }
                 m_the_pfn = m_name;
                 m_alreadyConnected = true;
              }
           }
        }
      } /* not PFN */
      else if ( m_nameType == Specification::LFN ) {
         m_the_fid = m_catalog.lookupLFN( m_name );
      }
      if ( ! m_the_fid.empty() ) {
        m_name = m_the_fid;
        m_nameType = Specification::FID;
      }
      return m_the_fid;
    }
    return emptyString;
  }
}

◆ fileDescriptor()

pool::FileDescriptor * Database::fileDescriptor ( )

Definition at line 355 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
  return m_databaseHandler? &m_databaseHandler->fileDescriptor() : nullptr;
}

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

183{ return msg() << lvl; }

AthMessaging::msg

MsgStream & msg() const

The standard message stream.

Definition AthMessaging.h:167

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns: boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

◆ openMode()

Io::IoFlag Database::openMode ( ) const

Returns the opening mode. It can be used to check whether the database is connected.

Definition at line 198 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
  return m_openMode;
}

◆ pfn()

const std::string & Database::pfn ( )

Returns the physical file name of this database.

Definition at line 263 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
  if( m_databaseHandler )  return m_databaseHandler->pfn();
  if( m_nameType == Specification::PFN )  return m_name;
  if( ! m_the_pfn.empty() )  return m_the_pfn;
  
  if( m_nameType == Specification::LFN ) {
     m_the_fid = m_catalog.lookupLFN( m_name );
     if ( ! m_the_fid.empty() ) {
        m_name = m_the_fid;
        m_nameType = Specification::FID;
        // go from FID=>PFN in the next step
     }
  }
  if( m_nameType == Specification::FID ) {
     std::string technology;
     FileCatalogUtils::getFirstPFN( m_catalog, m_name, m_the_pfn, technology );
     if( !m_the_pfn.empty() ) {
        m_the_fid = m_name;
        m_technology = pool::DbType::getType( technology ).majorType();
        m_alreadyConnected = true;
     }
     return m_the_pfn; 
  }
  return emptyString;
}

◆ readObject()

void * Database::readObject	(	const Token &	token,
		void *	object = 0 )

Reads an object given a token.

Definition at line 98 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
   if( !m_databaseHandler) {
      throw std::runtime_error( "Could not open a database for read object. (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
   }
   return m_databaseHandler->readObject( token, object );
}

◆ setAttributeOfType()

bool Database::setAttributeOfType	(	const std::string &	attributeName,
		const void *	data,
		const std::type_info &	typeInfo,
		const std::string &	option )

Definition at line 373 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
  if ( ! m_databaseHandler ) return false;
  else return m_databaseHandler->setAttribute( attributeName, data, typeInfo, option );
}

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

◆ setTechnology()

bool Database::setTechnology ( long technology )

Sets the technology identifier for this database.

This can only be called for newly created databases before the connect method is called. Otherwise false is returned.

Definition at line 291 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
  if ( m_alreadyConnected ) return false;
  else {
    pool::DbType dbType( technology );
    m_technology = dbType.majorType();
    m_technologySet = true;
    return true;
  }
}

◆ writeObject()

Token * Database::writeObject	(	const std::string &	containerName,
		long	minorTechnology,
		const void *	object,
		const RootType &	type )

Writes an object and returns a token.

Definition at line 175 of file Database/AthenaPOOL/PoolSvc/src/Database.cxx.

{
   if( !m_databaseHandler) {
      throw std::runtime_error( "Could not open a database for write object. (APR: \" Database::connectForWrite \" from \" PersistencySvc \")" );
   }
   return m_databaseHandler->writeObject( containerName, minorTechnology, object, type );
}

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

◆ m_alreadyConnected

bool Database::m_alreadyConnected

private

Flag indicating whether a connection has been already made once.

Definition at line 122 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_catalog

Gaudi::IFileCatalog& Database::m_catalog

private

Reference to the file catalog.

Definition at line 104 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_databaseHandler

DatabaseHandler* Database::m_databaseHandler

private

The underlying database handler.

Definition at line 118 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

◆ m_name

std::string Database::m_name

private

The database name.

Definition at line 110 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_nameType

Specification::NameType Database::m_nameType

private

The database name spacification.

Definition at line 112 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_openMode

Io::IoFlag Database::m_openMode

private

Current open mode.

Definition at line 120 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_registry

DatabaseRegistry& Database::m_registry

private

Reference to the database registry.

Definition at line 108 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_session

SessionTool& Database::m_session

private

Reference to the session.

Definition at line 102 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_technology

long Database::m_technology

private

The technology identifier of the database.

Definition at line 114 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_technologySet

bool Database::m_technologySet

private

Checks if the technology identifier has been set.

Definition at line 116 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_the_fid

std::string Database::m_the_fid

private

Other names used.

Definition at line 124 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_the_pfn

std::string Database::m_the_pfn

private

Definition at line 125 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

◆ m_transactionType

Io::IoFlag Database::m_transactionType

private

Transaction type (read/update).

Definition at line 106 of file Database/AthenaPOOL/PoolSvc/src/Database.h.

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

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Database()

◆ ~Database()

Member Function Documentation

◆ attributeOfType()

◆ checkInRegistry()

◆ connectForRead()

◆ connectForWrite()

◆ containerHandle()

◆ containers()

◆ disconnect()

◆ fid()

◆ fileDescriptor()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ openMode()

◆ pfn()

◆ readObject()

◆ setAttributeOfType()

◆ setLevel()

◆ setTechnology()

◆ writeObject()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_alreadyConnected

◆ m_catalog

◆ m_databaseHandler

◆ m_imsg

◆ m_lvl

◆ m_msg_tls

◆ m_name

◆ m_nameType

◆ m_nm

◆ m_openMode

◆ m_registry

◆ m_session

◆ m_technology

◆ m_technologySet

◆ m_the_fid

◆ m_the_pfn

◆ m_transactionType