RDBAccessSvc Class Reference

RDBAccessSvc is the implementation of IRDBAccessSvc interface. More...

#include <RDBAccessSvc.h>

Inheritance diagram for RDBAccessSvc:

Collaboration diagram for RDBAccessSvc:

Public Member Functions
	RDBAccessSvc (const std::string &name, ISvcLocator *svc)
	Standard Service Constructor.
StatusCode	initialize () override
StatusCode	finalize () override
bool	connect (std::string_view connName) override
	Connect to the relational DB.
bool	disconnect (std::string_view connName) override
	If the counnection counter==1 closes the connection.
bool	shutdown (std::string_view connName) override
	Closes the connection regardless of the counter value.
IRDBRecordset_ptr	getRecordsetPtr (std::string_view node, std::string_view tag, std::string_view tag2node="", std::string_view connName="ATLASDD") override
	Provides access to the Recordset object containing HVS-tagged data.
std::string	getChildTag (const std::string &childNode, const std::string &parentTag, const std::string &parentNode, const std::string &connName) override
	Gets the tag name for the node by giving its parent node tag.
std::string	getChildTag (const std::string &childNode, const std::string &parentTag, const std::string &parentNode, const std::string &connName, bool force)
std::unique_ptr< IRDBQuery >	getQuery (const std::string &node, const std::string &tag, const std::string &tag2node, const std::string &connName) override
void	getTagDetails (RDBTagDetails &tagDetails, const std::string &tag, const std::string &connName="ATLASDD") override
void	getAllLeafNodes (std::vector< std::string > &list, const std::string &connName="ATLASDD")
std::vector< std::string >	getLockedSupportedTags (const std::string &supportedFlag, const std::string &connName="ATLASDD")
coral::ISessionProxy *	getSession (const std::string &connName="ATLASDD")

Private Member Functions
bool	shutdown_connection (std::string_view connName)

Private Attributes
SessionMap	m_sessions
std::map< std::string, unsigned int, std::less<> >	m_openConnections
RecordsetPtrsByConn	m_recordsetptrs
GlobalTagLookupMap	m_globalTagLookup
std::mutex	m_recordsetMutex
std::mutex	m_sessionMutex

Detailed Description

RDBAccessSvc is the implementation of IRDBAccessSvc interface.

Definition at line 58 of file RDBAccessSvc.h.

Constructor & Destructor Documentation

RDBAccessSvc()

RDBAccessSvc::RDBAccessSvc	(	const std::string &	name,
		ISvcLocator *	svc )

Standard Service Constructor.

Definition at line 36 of file RDBAccessSvc.cxx.

  : base_class(name,svc)
{
}

Member Function Documentation

connect()

bool RDBAccessSvc::connect ( std::string_view connName )

override

Connect to the relational DB.

If this method is called for already open connection the connection counter is incremented.

Returns

success/failure

Definition at line 41 of file RDBAccessSvc.cxx.

{
  std::scoped_lock<std::mutex> guard(m_sessionMutex);
  const std::string connStr{connName};
  // Check if it is the first attempt to open a connection connName
  if(m_sessions.find(connName)==m_sessions.end()) {
    ATH_MSG_DEBUG(" Trying to open the connection " << connName << " for the first time");
    // Add initial entries for this connection to three maps
    // 1. Sessions
    // 2. open connections
    // 3. Recordset by connection
    m_sessions[connStr] = nullptr;
    m_openConnections[connStr] = 0;
    m_recordsetptrs.emplace(connName,RecordsetPtrMap());
  }
 
  // Use existing Connection Proxy if available
  if(m_openConnections[connStr]++) {
    ATH_MSG_DEBUG(" Connection " << connName << " already open, sessions = " << m_openConnections[connStr]);
    return true;
  }
 
  // Request new connection proxy from the Connection Service
  coral::ConnectionService conSvcH;
  coral::ISessionProxy *proxy = nullptr;
  try {
    proxy = conSvcH.connect(connStr,coral::ReadOnly);
    proxy->transaction().start(true);
    ATH_MSG_DEBUG("Proxy for connection "  << connName << " obtained");
  }
  catch(std::exception& e) {
    ATH_MSG_ERROR("Exception caught: " << e.what());
    m_openConnections[connStr]--;
    return false;
  }
 
  m_sessions[connStr] = proxy;
 
  return true;
}

disconnect()

bool RDBAccessSvc::disconnect ( std::string_view connName )

override

If the counnection counter==1 closes the connection.

Decrements the connection counter value otherwise.

Returns

success/failure

Definition at line 82 of file RDBAccessSvc.cxx.

{
  auto connection = m_openConnections.find(connName);
  if(connection==m_openConnections.end()) {
    ATH_MSG_ERROR("Wrong name for the connection: " << connName);
    return false;
  }
 
  std::scoped_lock<std::mutex> guard(m_sessionMutex); 
  if(connection->second>0) {
    connection->second--;
    
    ATH_MSG_DEBUG("Connection " << connName << " Sessions = " << connection->second);
 
    if(connection->second==0) {
      auto session = m_sessions.find(connName);
      if(session!=m_sessions.end()) {
    session->second->transaction().commit();
    delete session->second;
    session->second = nullptr;
      }
      
      ATH_MSG_DEBUG(connName << " Disconnected!");
    }
  }
  return true;
}

finalize()

StatusCode RDBAccessSvc::finalize ( )

override

Definition at line 521 of file RDBAccessSvc.cxx.

{
  m_recordsetptrs.clear();
 
  // Clear global tag lookup table
  for(auto& [lookupName,lookup] : m_globalTagLookup) {
    delete lookup;
  }
  m_globalTagLookup.clear();
 
  // Shut down all connections
  for(auto& [sessionName,session] : m_sessions) {
    shutdown(sessionName);
  }
 
  return StatusCode::SUCCESS;
}

getAllLeafNodes()

void RDBAccessSvc::getAllLeafNodes	(	std::vector< std::string > &	list,
		const std::string &	connName = "ATLASDD" )

Definition at line 429 of file RDBAccessSvc.cxx.

{
  list.clear();
  if(!connect(connName)) {
    ATH_MSG_ERROR("Failed to open Connection " << connName);
    return;
  }
 
  coral::ISessionProxy* session = m_sessions[connName];
  try {
    coral::ITable& tableNode = session->nominalSchema().tableHandle("HVS_NODE");
    coral::IQuery *queryNode = tableNode.newQuery();
    queryNode->addToOutputList("NODE_NAME");
    queryNode->setMemoryCacheSize(1);
    coral::AttributeList empty ATLAS_THREAD_SAFE;
    queryNode->setCondition("BRANCH_FLAG=0", empty);
    queryNode->addToOrderList("NODE_NAME");
    
    coral::ICursor& cursorNode = queryNode->execute();
    while(cursorNode.next()) {
      list.push_back(cursorNode.currentRow()["NODE_NAME"].data<std::string>());
    }
    
    delete queryNode;
  }
  catch(coral::SchemaException& se) {
    ATH_MSG_INFO("Schema Exception : " << se.what());
  }
  catch(std::exception& e) {
    ATH_MSG_ERROR(e.what());
  }
  catch(...) {
    ATH_MSG_ERROR("Exception caught(...)");
  }
 
  disconnect(connName);
}

getChildTag() [1/2]

std::string RDBAccessSvc::getChildTag ( const std::string & childNode, const std::string & parentTag, const std::string & parentNode, const std::string & connName )

override

Gets the tag name for the node by giving its parent node tag.

Parameters

childNode	[IN] name of the child node
parentTag	[IN] name of the parent tag
parentNode	[IN] name of the parent node
fetchData	[IN] if true fetch the corresponding data this parameter has no sence if child is the branch node

Definition at line 285 of file RDBAccessSvc.cxx.

{
  return getChildTag(childNode
             , parentTag
             , parentNode
             , connName
             , false);
}

getChildTag() [2/2]

std::string RDBAccessSvc::getChildTag	(	const std::string &	childNode,
		const std::string &	parentTag,
		const std::string &	parentNode,
		const std::string &	connName,
		bool	force )

Definition at line 297 of file RDBAccessSvc.cxx.

{
  ATH_MSG_DEBUG("getChildTag for " << childNode << " " << parentTag << " " << parentNode);
  Athena::DBLock dblock;
  std::scoped_lock<std::mutex> guard(m_recordsetMutex);
 
  // Check lookup table first
  std::string lookupMapKey = parentTag + "::" + connName;
  GlobalTagLookupMap::const_iterator lookupmap = m_globalTagLookup.find(lookupMapKey);
  if(lookupmap!=m_globalTagLookup.end()) {
    TagNameIdByNode::const_iterator childtagdet = lookupmap->second->find(childNode);
    if(childtagdet!=lookupmap->second->end()) {
      return childtagdet->second.first;
    }
    else {
      if(!force) {
    return std::string("");
      }
    }
  }
 
  if(!connect(connName)) {
    ATH_MSG_ERROR("Unable to open connection " << connName << ". Returning empty string");
    return std::string("");
  }
 
  std::string childTag("");
  try {
    // We don't have lookup table for given parent tag. Go into slow mode through Version Accessor
    coral::ISessionProxy* session = m_sessions[connName];
    RDBVersionAccessor versionAccessor(childNode,parentNode,parentTag,session,msg());
    versionAccessor.getChildTagData();
 
    childTag = versionAccessor.getTagName();
  }
  catch(coral::SchemaException& se) {
    ATH_MSG_ERROR("Schema Exception : " << se.what());
  }
  catch(std::exception& e) {
    ATH_MSG_ERROR(e.what());
  }
  catch(...) {
    ATH_MSG_ERROR("Exception caught(...)");
  }
 
  disconnect(connName);
 
  return childTag;
}

getLockedSupportedTags()

std::vector< std::string > RDBAccessSvc::getLockedSupportedTags	(	const std::string &	supportedFlag,
		const std::string &	connName = "ATLASDD" )

Definition at line 468 of file RDBAccessSvc.cxx.

{
  std::vector<std::string> taglist;
  if(!connect(connName)) {
    ATH_MSG_ERROR("Failed to open connection " << connName);
  }
  else {
    try{
      coral::ISessionProxy* session = m_sessions[connName];
 
      coral::ITable& tableTag2Node = session->nominalSchema().tableHandle("HVS_TAG2NODE");
      coral::IQuery* queryTag2Node = tableTag2Node.newQuery();
      queryTag2Node->addToOutputList("TAG_NAME");
      queryTag2Node->setMemoryCacheSize(1);
      coral::AttributeList empty ATLAS_THREAD_SAFE;
      std::string condString = std::string("NODE_ID=0 AND LOCKED=1 AND SUPPORTED>=")+supportedFlag;
      queryTag2Node->setCondition(condString,empty);
      queryTag2Node->addToOrderList("TAG_NAME");
 
      coral::ICursor& cursorTagName = queryTag2Node->execute();
      while(cursorTagName.next()) {
    const coral::AttributeList& row = cursorTagName.currentRow();
    taglist.push_back(row["TAG_NAME"].data<std::string>());
      }
      delete queryTag2Node;
 
    } 
    catch(coral::SchemaException& se) {
      ATH_MSG_ERROR("Schema Exception : " << se.what());
    }
    catch(std::exception& e) {
      ATH_MSG_ERROR(e.what());
    }
    catch(...) {
      ATH_MSG_ERROR("Exception caught(...)");
    }    
  }
  disconnect(connName);
  return taglist;
}

getQuery()

std::unique_ptr< IRDBQuery > RDBAccessSvc::getQuery ( const std::string & node, const std::string & tag, const std::string & tag2node, const std::string & connName )

override

Definition at line 229 of file RDBAccessSvc.cxx.

{
  ATH_MSG_DEBUG("getQuery (" << node << "," << tag << "," << tag2node << "," << connName << ")");
  Athena::DBLock dblock;
  std::scoped_lock<std::mutex> guard(m_recordsetMutex);
 
  std::unique_ptr<IRDBQuery> query;
 
  if(!connect(connName)) {
    ATH_MSG_ERROR("Unable to open connection " << connName << ". Returning nullptr to IRDBQuery");
    return query;
  }
 
  coral::ISessionProxy* session = m_sessions[connName];
 
  try {
    // Check lookup table first
    std::string childTagId("");
    std::string lookupMapKey = tag + "::" + connName;
    GlobalTagLookupMap::const_iterator lookupmap = m_globalTagLookup.find(lookupMapKey);
    if(lookupmap!=m_globalTagLookup.end()) {
      TagNameIdByNode::const_iterator childtagdet = lookupmap->second->find(node);
      if(childtagdet!=lookupmap->second->end()) {
    childTagId = childtagdet->second.second;
      }
    }
    else {
      RDBVersionAccessor versionAccessor{node,(tag2node.empty()?node:tag2node),tag,session,msg()};
      versionAccessor.getChildTagData();
      childTagId = versionAccessor.getTagID();
    }
 
    if(childTagId.empty()) {
      ATH_MSG_WARNING("Could not get the tag for " << node << " node. Returning 0 pointer to IRDBQuery");
    }
    else {
      query = std::unique_ptr<IRDBQuery>(new RDBQuery(dblock,this,node,childTagId,connName));
    }
  }
  catch(coral::SchemaException& se) {
    ATH_MSG_ERROR("Schema Exception : " << se.what());
  }
  catch(std::exception& e) {
    ATH_MSG_ERROR(e.what());
  }
  catch(...) {
    ATH_MSG_ERROR("Exception caught(...)");
  }
 
  disconnect(connName);
  return query;
}

getRecordsetPtr()

IRDBRecordset_ptr RDBAccessSvc::getRecordsetPtr ( std::string_view node, std::string_view tag, std::string_view tag2node = "", std::string_view connName = "ATLASDD" )

override

Provides access to the Recordset object containing HVS-tagged data.

Parameters

node	[IN] name of the leaf HVS node
tag	[IN] tag of the HVS node specified by node parameter if tag2node is omitted, tag of the HVS branch node specified by tag2node otherwise
tag2node	[IN] some parent of the HVS leaf node specified by node parameter

Returns

pointer to the recordset object

Definition at line 150 of file RDBAccessSvc.cxx.

{
  static const std::string dc{"::"};//double colon
  std::string key;
  key.reserve(node.size() + tag.size() + tag2node.size() + 4);
  key.append(node);
  key.append(dc);
  key.append(tag);
  if(!tag2node.empty()){
    key.append(dc);
    key.append(tag2node);
  }
  const std::string connStr{connName};
  ATH_MSG_DEBUG("Getting RecordsetPtr with key " << key);
 
  Athena::DBLock dblock;
  std::scoped_lock<std::mutex> guard(m_recordsetMutex);
 
  RecordsetPtrMap& recordsets = m_recordsetptrs[connStr];
  RecordsetPtrMap::const_iterator it = recordsets.find(key);
  if(it != recordsets.end()) {
    ATH_MSG_DEBUG("Reusing existing recordset");
    return it->second;
  }
 
  if(!connect(connName)) {
    ATH_MSG_ERROR("Unable to open connection " << connName << ". Returning empty recordset");
    return IRDBRecordset_ptr(new RDBRecordset(this));
  }
 
  RDBRecordset* recConcrete = new RDBRecordset(this);
  IRDBRecordset_ptr rec(recConcrete);
  coral::ISessionProxy* session = m_sessions[connStr];
 
  try {
    // Check lookup table first
    std::string lookupMapKey;
    lookupMapKey.reserve(tag.size() + connName.size() + 2);
    lookupMapKey.append(tag);
    lookupMapKey.append(dc);
    lookupMapKey.append(connName);
    //
    const std::string nodeStr{node};
    GlobalTagLookupMap::const_iterator lookupmap = m_globalTagLookup.find(lookupMapKey);
    if(lookupmap!=m_globalTagLookup.end()) {
      TagNameIdByNode::const_iterator childtagdet = lookupmap->second->find(node);
      if(childtagdet!=lookupmap->second->end()) {
    recConcrete->getData(session,nodeStr,childtagdet->second.first,childtagdet->second.second);
      }
      else {
    recConcrete->setNodeName(nodeStr);
    ATH_MSG_DEBUG("Unable to find tag for the node " << node << " in the cache of global tag " << tag << ". Returning empty recordset");
      }
    }
    else {
      const std::string str{tag2node.empty()?node:tag2node};
      RDBVersionAccessor versionAccessor(nodeStr,str,std::string{tag},session,msg());
      versionAccessor.getChildTagData();
      recConcrete->getData(session,versionAccessor.getNodeName(),versionAccessor.getTagName(),versionAccessor.getTagID());
    }
  }
  catch(coral::SchemaException& se) {
    ATH_MSG_ERROR("Schema Exception : " << se.what());
  }
  catch(std::exception& e) {
    ATH_MSG_ERROR(e.what());
  }
  catch(...) {
    ATH_MSG_ERROR("Exception caught(...)");
  }
 
  recordsets.emplace(key,rec);
  disconnect(connName);
  return rec;
}

getSession()

coral::ISessionProxy * RDBAccessSvc::getSession

(

const std::string &

connName = "ATLASDD"

)

Definition at line 510 of file RDBAccessSvc.cxx.

{
  auto sessionIt = m_sessions.find(connName);
  return sessionIt == m_sessions.end() ? nullptr : sessionIt->second;
}

getTagDetails()

void RDBAccessSvc::getTagDetails ( RDBTagDetails & tagDetails, const std::string & tag, const std::string & connName = "ATLASDD" )

override

Definition at line 351 of file RDBAccessSvc.cxx.

{
  ATH_MSG_DEBUG("getTagDetails for tag: " << tag);
  Athena::DBLock dblock;
  std::scoped_lock<std::mutex> guard(m_recordsetMutex);
 
  if(!connect(connName)) {
    ATH_MSG_ERROR("Failed to open connection " << connName);
  }
 
  coral::ISessionProxy* session = m_sessions[connName];
  try {
    coral::ITable& tableTag2Node = session->nominalSchema().tableHandle("HVS_TAG2NODE");
    coral::IQuery *queryTag2Node = tableTag2Node.newQuery();
    queryTag2Node->addToOutputList("LOCKED");
    queryTag2Node->addToOutputList("SUPPORTED");
    queryTag2Node->setMemoryCacheSize(1);
    coral::AttributeList bindsTag2Node ATLAS_THREAD_SAFE;
    bindsTag2Node.extend<std::string>("tagN");
    queryTag2Node->setCondition("TAG_NAME=:tagN", bindsTag2Node);
    bindsTag2Node[0].data<std::string>() = tag;
    
    coral::ICursor& cursorTag2Node = queryTag2Node->execute();
    if(cursorTag2Node.next()) {
      tagDetails = cursorTag2Node.currentRow();
    }
    
    delete queryTag2Node;
 
    // Build lookup table for the given global tag if has not been built yet
    std::string lookupMapKey = tag + "::" + connName;
    if(m_globalTagLookup.find(lookupMapKey)==m_globalTagLookup.end()) {
      // Get tag contents from the database
      TagNameIdByNode* lookup = new TagNameIdByNode();
      
      coral::ITable& tableRootTag2Child = session->nominalSchema().tableHandle("HVS_TAGCACHE");
      coral::IQuery* queryRootTag2Child = tableRootTag2Child.newQuery();
      queryRootTag2Child->addToOutputList("CHILDNODE");
      queryRootTag2Child->addToOutputList("CHILDTAG");
      queryRootTag2Child->addToOutputList("CHILDTAGID");
      queryRootTag2Child->setMemoryCacheSize(1);
      coral::AttributeList bindsRootTag2Child ATLAS_THREAD_SAFE;
      bindsRootTag2Child.extend<std::string>("tagN");
      queryRootTag2Child->setCondition("ROOTTAG=:tagN", bindsRootTag2Child);
      bindsRootTag2Child[0].data<std::string>() = tag;
      queryRootTag2Child->addToOrderList("CHILDNODE");
      
      coral::ICursor& cursorRootTag2Child = queryRootTag2Child->execute();
      while(cursorRootTag2Child.next()) {
    const coral::AttributeList& row = cursorRootTag2Child.currentRow();
    (*lookup)[row["CHILDNODE"].data<std::string>()]=std::make_pair(row["CHILDTAG"].data<std::string>(),std::to_string(row["CHILDTAGID"].data<long long>()));
      }
 
      delete queryRootTag2Child;
      
      if(lookup->size()>0) {
    m_globalTagLookup[lookupMapKey]=lookup;
      }
      else {
    delete lookup;
      }
    }
  }
  catch(coral::SchemaException& se) {
    ATH_MSG_INFO("Schema Exception : " << se.what());
  }
  catch(std::exception& e) {
    ATH_MSG_ERROR(e.what());
  }
  catch(...) {
    ATH_MSG_ERROR("Exception caught(...)");
  }
  
  disconnect(connName);
}

initialize()

StatusCode RDBAccessSvc::initialize ( )

override

Definition at line 516 of file RDBAccessSvc.cxx.

{
  return StatusCode::SUCCESS;
}

shutdown()

bool RDBAccessSvc::shutdown ( std::string_view connName )

override

Closes the connection regardless of the counter value.

Returns

success/failure

Definition at line 110 of file RDBAccessSvc.cxx.

{
  if(connName=="*Everything*") {
    for(const auto& ii : m_openConnections) {
      if(ii.second != 0) {
    ATH_MSG_INFO("Close everything: Connection: " << ii.first << " with reference count = " << ii.second << " will be closed.");
    if(!shutdown_connection(ii.first)) {
      return false;
    }
      }
    }
    return true;
  }
  
  return shutdown_connection(connName);
}

shutdown_connection()

bool RDBAccessSvc::shutdown_connection ( std::string_view connName )

private

Definition at line 127 of file RDBAccessSvc.cxx.

{
  auto connection = m_openConnections.find(connName);
  if(connection==m_openConnections.end()) {
    ATH_MSG_ERROR("Wrong name for the connection: " << connName);
    return false;
  }
  std::scoped_lock<std::mutex> guard(m_sessionMutex);
  connection->second = 0;
  
  auto session = m_sessions.find(connName);
  if(session!=m_sessions.end() 
     && session->second) {
    session->second->transaction().commit();
    delete session->second;
    session->second = nullptr;
  }
  
  ATH_MSG_DEBUG(connName << " Disconnected!");
 
  return true;
}

Member Data Documentation

m_globalTagLookup

GlobalTagLookupMap RDBAccessSvc::m_globalTagLookup

private

Definition at line 132 of file RDBAccessSvc.h.

m_openConnections

std::map<std::string, unsigned int, std::less<> > RDBAccessSvc::m_openConnections

private

Definition at line 129 of file RDBAccessSvc.h.

m_recordsetMutex

std::mutex RDBAccessSvc::m_recordsetMutex

private

Definition at line 134 of file RDBAccessSvc.h.

m_recordsetptrs

RecordsetPtrsByConn RDBAccessSvc::m_recordsetptrs

private

Definition at line 131 of file RDBAccessSvc.h.

m_sessionMutex

std::mutex RDBAccessSvc::m_sessionMutex

private

Definition at line 135 of file RDBAccessSvc.h.

m_sessions

SessionMap RDBAccessSvc::m_sessions

private

Definition at line 128 of file RDBAccessSvc.h.

---

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

• RDBAccessSvc.h
• RDBAccessSvc.cxx