---

cond::SequenceManager Class Reference

#include <CondCore/DBCommon/interface/SequenceManager.h>

List of all members.

Public Member Functions
void	clear ()
	Clears the internal state.
void	createSequencesTable ()
	Creates the table holding the sequences.
bool	existSequencesTable ()
	Whether sequence table exists.
unsigned long long	incrementId (const std::string &reftableName)
	Increments and returns a new valid oid for a table.
	SequenceManager (cond::CoralTransaction &coraldb, const std::string &sequenceTableName)
	Constructor.
void	updateId (const std::string &reftableName, unsigned long long lastId)
	Updates the last used id.
	~SequenceManager ()
	Destructor.
Private Member Functions
void	init ()
bool	lockEntry (coral::ISchema &schema, const std::string &reftableName, unsigned long long &lastId)
	Locks the id entry in the ref table and returns the lastId value.
Private Attributes
cond::CoralTransaction &	m_coraldb
	The coraldb in use.
bool	m_sequenceTableExists
	Flag indicating whether the sequence table exists.
std::string	m_sequenceTableName
	Sequence table name.
std::string	m_setClause
	The set clause for updating a sequence entry.
bool	m_started
std::map< std::string, unsigned long long >	m_tableToId
	Map of ids used.
std::string	m_whereClause
	The where clause pinning a sequence entry.
coral::AttributeList *	m_whereData
	The data for the where clause.

---

Detailed Description

Definition at line 22 of file SequenceManager.h.

---

Constructor & Destructor Documentation

SequenceManager::SequenceManager	(	cond::CoralTransaction &	coraldb,
		const std::string &	sequenceTableName
	)

Constructor.

Definition at line 17 of file SequenceManager.cc.

References init(), and m_whereData.

00018                                                                           :
00019   m_coraldb(coraldb),
00020   m_sequenceTableName( sequenceTableName ),
00021   m_tableToId(),
00022   m_sequenceTableExists( false ),
00023   m_whereClause( std::string("REFTABLE_NAME")+" =:"+std::string("REFTABLE_NAME")), 
00024   m_whereData( 0 ),
00025   m_setClause( std::string("IDVALUE")+" = "+std::string("IDVALUE")+" + 1"),
00026   m_started( false )
00027 {
00028   m_whereData = new coral::AttributeList; 
00029   m_whereData->extend<std::string>(std::string("REFTABLE_NAME"));
00030   init();
00031 }
void

SequenceManager::~SequenceManager

(

)

Destructor.

Definition at line 37 of file SequenceManager.cc.

References m_whereData.

{  
  delete m_whereData;
}

---

Member Function Documentation

void SequenceManager::clear

(

void

)

Clears the internal state.

Definition at line 137 of file SequenceManager.cc.

References m_tableToId.

{
  m_tableToId.clear();
}

void SequenceManager::createSequencesTable

(

)

Creates the table holding the sequences.

Definition at line 146 of file SequenceManager.cc.

References description, m_coraldb, m_sequenceTableExists, m_sequenceTableName, cond::CoralTransaction::nominalSchema(), and python::listobjects::schema.

Referenced by cond::Logger::createLogDBIfNonExist().

{
  coral::ISchema& schema= m_coraldb.nominalSchema();
  coral::TableDescription description( "CONDSEQ" );
  description.setName(m_sequenceTableName);
  description.insertColumn(std::string("REFTABLE_NAME"),
                           coral::AttributeSpecification::typeNameForType<std::string>() );
  description.setNotNullConstraint(std::string("REFTABLE_NAME"));
  description.insertColumn(std::string("IDVALUE"),
                           coral::AttributeSpecification::typeNameForType<unsigned long long>() );
  description.setNotNullConstraint(std::string("IDVALUE"));
  description.setPrimaryKey( std::vector< std::string >( 1, std::string("REFTABLE_NAME")));
  schema.createTable( description ).privilegeManager().grantToPublic( coral::ITablePrivilegeManager::Select );
  m_sequenceTableExists=true;
}

bool SequenceManager::existSequencesTable

(

)

Whether sequence table exists.

Definition at line 142 of file SequenceManager.cc.

References m_sequenceTableExists.

Referenced by cond::Logger::createLogDBIfNonExist().

                                        {
  return m_sequenceTableExists;
}

unsigned long long SequenceManager::incrementId

(

const std::string &

reftableName

)

Increments and returns a new valid oid for a table.

Definition at line 42 of file SequenceManager.cc.

References exception, Exception, lockEntry(), m_coraldb, m_sequenceTableExists, m_sequenceTableName, m_setClause, m_tableToId, m_whereClause, m_whereData, cond::CoralTransaction::nominalSchema(), and python::listobjects::schema.

Referenced by cond::Logger::logFailedOperationNow(), and cond::Logger::logOperationNow().

                                                            {
  std::map< std::string, unsigned long long >::iterator iSequence = m_tableToId.find( tableName );
  coral::ISchema& schema=m_coraldb.nominalSchema();
  if ( iSequence == m_tableToId.end() ) {
    // Make sure that the sequence table exists.
    if ( ! m_sequenceTableExists ) {
      throw cond::Exception("SequenceManager::incrementId");
    }
    // Lock the entry in the table.
    unsigned long long lastIdUsed = 0;
    if ( ! ( this->lockEntry( schema, tableName, lastIdUsed ) ) ) {
      // Create the entry in the table if it does not exist.
      coral::AttributeList rowData;
      rowData.extend<std::string>("REFTABLE_NAME");
      rowData.extend<unsigned long long>("IDVALUE");
      coral::AttributeList::iterator iAttribute = rowData.begin();
      iAttribute->data< std::string >() = tableName;
      ++iAttribute;
      unsigned long long startingIdValue = lastIdUsed;
      iAttribute->data< unsigned long long >() = startingIdValue;
      try{
        schema.tableHandle( m_sequenceTableName ).dataEditor().insertRow( rowData );
        m_tableToId.insert( std::make_pair( tableName, startingIdValue ) );
        return startingIdValue;
      }catch(const coral::DataEditorException& er){
        //std::cout<<"cannot insert, probably already created by others, try lock again"<<std::endl;
        this->lockEntry( schema, tableName, lastIdUsed );
        ++lastIdUsed;
        iSequence = m_tableToId.insert( std::make_pair( tableName, lastIdUsed ) ).first;
        m_whereData->begin()->data<std::string>() = tableName;
        schema.tableHandle(m_sequenceTableName).dataEditor().updateRows(m_setClause,m_whereClause,*m_whereData );
        return lastIdUsed;
        //startingIdValue = lastIdUsed+1;
        //m_tableToId.insert( std::make_pair( tableName, startingIdValue ) );
      }catch(std::exception& er){
        //std::cout<<"real error "<<er.what()<<std::endl;
        throw cond::Exception(er.what());
      }

    }
    // Add the entry into the map.
    iSequence = m_tableToId.insert( std::make_pair( tableName, lastIdUsed ) ).first;
  }
  // Increment the oid transiently
  unsigned long long& oid = iSequence->second;
  this->lockEntry( schema, tableName, oid );
  ++oid;
  // Increment the oid in the database as well
  
  m_whereData->begin()->data<std::string>() = tableName;
  schema.tableHandle(m_sequenceTableName).dataEditor().updateRows(m_setClause,m_whereClause,*m_whereData );
  
  return oid;
}

void SequenceManager::init

(

void

)

[private]

Definition at line 33 of file SequenceManager.cc.

References m_coraldb, m_sequenceTableExists, m_sequenceTableName, m_started, and cond::CoralTransaction::nominalSchema().

Referenced by SequenceManager().

                         { 
  m_sequenceTableExists=m_coraldb.nominalSchema().existsTable(m_sequenceTableName) ;
  m_started=true;
}

bool SequenceManager::lockEntry	(	coral::ISchema &	schema,
		const std::string &	reftableName,
		unsigned long long &	lastId
	)			[private]

Locks the id entry in the ref table and returns the lastId value.

Definition at line 163 of file SequenceManager.cc.

References m_sequenceTableName, m_whereClause, and m_whereData.

Referenced by incrementId().

                                                              {
  std::auto_ptr< coral::IQuery > query( schema.tableHandle(m_sequenceTableName).newQuery());
  query->limitReturnedRows( 1, 0 );
  query->addToOutputList( std::string("IDVALUE") );
  query->defineOutputType( std::string("IDVALUE"), coral::AttributeSpecification::typeNameForType<unsigned long long>() );
  query->setForUpdate();
  m_whereData->begin()->data< std::string >() = sequenceName;
  query->setCondition( m_whereClause, *m_whereData );
  coral::ICursor& cursor = query->execute();
  if ( cursor.next() ) {
    lastId = cursor.currentRow().begin()->data< unsigned long long >();
    //std::cout<<"sequence table lastId "<<lastId<<std::endl;
    //cursor.close();
    //std::cout<<"SequenceManager::lockEntry return true"<<std::endl;
    return true;
  }else {
    cursor.close();
    //std::cout<<"SequenceManager::lockEntry return false"<<std::endl;
    return false;
  }
}

void cond::SequenceManager::updateId	(	const std::string &	reftableName,
		unsigned long long	lastId
	)

Updates the last used id.

---

Member Data Documentation

cond::CoralTransaction& cond::SequenceManager::m_coraldb [private]

The coraldb in use.

Definition at line 56 of file SequenceManager.h.

Referenced by createSequencesTable(), incrementId(), and init().

bool cond::SequenceManager::m_sequenceTableExists [private]

Flag indicating whether the sequence table exists.

Definition at line 65 of file SequenceManager.h.

Referenced by createSequencesTable(), existSequencesTable(), incrementId(), and init().

std::string cond::SequenceManager::m_sequenceTableName [private]

Sequence table name.

Definition at line 59 of file SequenceManager.h.

Referenced by createSequencesTable(), incrementId(), init(), and lockEntry().

std::string cond::SequenceManager::m_setClause [private]

The set clause for updating a sequence entry.

Definition at line 74 of file SequenceManager.h.

Referenced by incrementId().

bool cond::SequenceManager::m_started [private]

Definition at line 75 of file SequenceManager.h.

Referenced by init().

std::map< std::string, unsigned long long > cond::SequenceManager::m_tableToId [private]

Map of ids used.

Definition at line 62 of file SequenceManager.h.

Referenced by clear(), and incrementId().

std::string cond::SequenceManager::m_whereClause [private]

The where clause pinning a sequence entry.

Definition at line 68 of file SequenceManager.h.

Referenced by incrementId(), and lockEntry().

coral::AttributeList* cond::SequenceManager::m_whereData [private]

The data for the where clause.

Definition at line 71 of file SequenceManager.h.

Referenced by incrementId(), lockEntry(), SequenceManager(), and ~SequenceManager().

---

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

• CondCore/DBCommon/interface/SequenceManager.h
• CondCore/DBCommon/src/SequenceManager.cc

---