DatabaseHandler.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include "DatabaseHandler.h"
#include "Container.h"
#include "PersistentDataModel/Token.h"
#include "StorageSvc/IStorageSvc.h"
#include "StorageSvc/Shape.h"
#include "StorageSvc/DbDatabase.h"
#include "StorageSvc/DbOption.h"
#include "StorageSvc/DbReflex.h"
#include "StorageSvc/DbTypeInfo.h"
#include "StorageSvc/DbConnection.h"
#include "StorageSvc/DbPrint.h"
 
#include <exception>
#include <memory>
 
pool::DatabaseHandler::DatabaseHandler( pool::IStorageSvc& storageSvc,
                                                        long technology,
                                                        const std::string& fid,
                                                        const std::string& pfn,
                                                        Io::IoFlag accessmode ):
  m_storageSvc( storageSvc ),
  m_fileDescriptor( fid, pfn ),
  m_technology( technology ),
  m_accessMode( accessmode )
{
  if ( ! m_storageSvc.connect( m_accessMode, m_fileDescriptor ).isSuccess() ) {
    throw std::runtime_error( "Could not connect to the database (APR: \" DatabaseHandler::DatabaseHandler \" from \" PersistencySvc \")" );
  }
}
 
pool::DatabaseHandler::~DatabaseHandler()
{
   Io::IoFlag mode = Io::INVALID;
   if( m_storageSvc.openMode(m_fileDescriptor, mode).isSuccess() ) {
     m_storageSvc.disconnect( m_fileDescriptor ).ignore();
   }
}
 
 
bool
pool::DatabaseHandler::commitTransaction()
{
   return m_storageSvc.endTransaction( m_fileDescriptor, Transaction::TRANSACT_COMMIT ).isSuccess() &&
          m_storageSvc.endTransaction( m_fileDescriptor, Transaction::TRANSACT_FLUSH ).isSuccess();
}
 
 
bool
pool::DatabaseHandler::commitAndHoldTransaction()
{
   return m_storageSvc.endTransaction( m_fileDescriptor, Transaction::TRANSACT_COMMIT ).isSuccess();
}
 
 
bool
pool::DatabaseHandler::disconnectTransaction()
{
   return ( m_storageSvc.disconnect( m_fileDescriptor ).isSuccess() );
}
 
std::vector< std::string >
pool::DatabaseHandler::containers()
{
   std::vector< std::string > result;
   std::vector<const Token*> containerTokens;
   DbDatabase dbH( m_fileDescriptor.dbc()->handle() );
   if( !dbH.containers(containerTokens, false).isSuccess() ) {
      DbPrint log( m_fileDescriptor.PFN() );
      log << MSG::ERROR << "Could not retrieve the list of containers." << endmsg;
   }
   for ( std::vector<const Token*>::const_iterator iToken = containerTokens.begin();
         iToken != containerTokens.end(); ++iToken ) {
      Token tok (*iToken);
      result.push_back( m_storageSvc.getContName(m_fileDescriptor, tok) );
   }
   return result;
}
 
pool::IContainer*
pool::DatabaseHandler::container( const std::string& containerName )
{
   // Check the existence of a given container.
   std::vector< std::string > allContainers = this->containers();
   for ( std::vector< std::string >::const_iterator iName = allContainers.begin();
         iName != allContainers.end(); ++iName ) {
      if ( *iName == containerName ) {
         return new pool::Container( m_fileDescriptor,
                                                     m_technology,
                                                     containerName );
      }
   }
   return 0;
}
 
 
const std::string&
pool::DatabaseHandler::pfn() const
{
  return m_fileDescriptor.PFN();
}
 
 
const std::string&
pool::DatabaseHandler::fid() const
{
  return m_fileDescriptor.FID();
}
 
 
long
pool::DatabaseHandler::technology() const
{
  return m_technology;
}
 
 
Io::IoFlag
pool::DatabaseHandler::accessMode() const
{
  return m_accessMode;
}
 
 
Token*
pool::DatabaseHandler::writeObject( const std::string& containerName,
                                                    long minorTechnology,
                                                    const void* object,
                                                    const RootType& type )
{
  Token* token = 0;
  if ( ! object ) return token;
 
  // Get the persistent shape.
  const pool::Shape* shape = nullptr;
  Guid guid = DbReflex::guid(type);
  if( !m_storageSvc.getShape( m_fileDescriptor, guid, shape ).isSuccess() ) {
     shape = m_storageSvc.createShape( guid );
  }
  if ( shape )  {
    if ( m_storageSvc.allocate( m_fileDescriptor,
                                containerName,
                                minorTechnology,
                                object,
                                shape, 
                                token ).isSuccess() ) {
      token->setClassID( shape->shapeID() );
    }
  }
  return token;
}
 
 
void*
pool::DatabaseHandler::readObject( const Token& token, void* object )
{
  void* result( object );
 
  // Get the persistent shape
  const pool::Shape* shape = nullptr;
  if( !m_storageSvc.getShape( m_fileDescriptor, token.classID(), shape ).isSuccess() ) {
    return result;
  }
  if( !m_storageSvc.read( m_fileDescriptor, token, shape, &result ).isSuccess() ) {
    return nullptr;
  }
  
  return result;
}
 
 
bool
pool::DatabaseHandler::attribute( const std::string& attributeName,
                                                  void* data,
                                                  const std::type_info& typeInfo,
                                                  const std::string& option )
{
  pool::DbOption databaseOption( attributeName, option );
  DbDatabase dbH( m_fileDescriptor.dbc()->handle() );
  if( !dbH.getOption(databaseOption).isSuccess() ) return false;
  return databaseOption.i_getValue(typeInfo, data).isSuccess();
}
 
 
bool
pool::DatabaseHandler::setAttribute( const std::string& attributeName,
                                                     const void* data,
                                                     const std::type_info& typeInfo,
                                                     const std::string& option )
{
  pool::DbOption databaseOption( attributeName, option );
  if( !databaseOption.i_setValue( typeInfo, const_cast<void*>( data ) ).isSuccess() ) return false;
  DbDatabase dbH( m_fileDescriptor.dbc()->handle() );
  return dbH.setOption(databaseOption).isSuccess();
  }