SqliteReadSvc.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 

 
#include "SqliteReadSvc.h"
#include "SqliteRecordset.h"
#include <sqlite3.h>
 
#include "RDBQuery.h"
 
SqliteReadSvc::SqliteReadSvc(const std::string& name, ISvcLocator* svc)
  : base_class(name,svc)
{
}
 
StatusCode SqliteReadSvc::finalize()
{
  m_recordsets.clear();
  shutdown("");
 
  return StatusCode::SUCCESS;
}
 
bool SqliteReadSvc::connect(std::string_view connName)
{
  std::lock_guard<std::mutex> guard(m_sessionMutex);
  const std::string connNameStr{connName};
  if(!m_db) {
    int res = sqlite3_open(connNameStr.c_str(), &m_db);
    if (res != SQLITE_OK) {
      ATH_MSG_FATAL("Failed to open " << connName << ". " << sqlite3_errmsg(m_db));
      return false;
    }
  }
  return true;
}
 
bool SqliteReadSvc::disconnect(std::string_view)
{
  // Dummy implementation
  return true;
}
 
bool SqliteReadSvc::shutdown(std::string_view)
{
  std::lock_guard<std::mutex> guard(m_sessionMutex);
  if(m_db) {
    sqlite3_close(m_db);
    m_db = nullptr;
  }
  return true;
}
 
 
IRDBRecordset_ptr SqliteReadSvc::getRecordsetPtr(std::string_view node
                        , std::string_view 
                        , std::string_view
                        , std::string_view )
{
  ATH_MSG_DEBUG("Getting RecordsetPtr with key " << node);
 
  std::lock_guard<std::mutex> guard(m_sessionMutex);
  if(!m_db) {
    ATH_MSG_ERROR("Connection to the SQLite database not open. Returning empty recordset");
    return IRDBRecordset_ptr(new SqliteRecordset());
  }
 
  auto itRecordset = m_recordsets.find(node);
  if(itRecordset!=m_recordsets.end()) {
    ATH_MSG_DEBUG("Reusing an existing recordset");
    return itRecordset->second;
  }
  const std::string nodeStr{node};
  SqliteRecordset* recConcrete = new SqliteRecordset();
  recConcrete->getData(m_db,nodeStr);
  IRDBRecordset_ptr rec(recConcrete);
  m_recordsets.emplace(nodeStr,rec);
  return rec;
}
 
std::unique_ptr<IRDBQuery> SqliteReadSvc::getQuery(const std::string& node
                          , const std::string& tag
                          , const std::string& tag2node
                          , const std::string& connName)
{
  ATH_MSG_DEBUG("getQuery (" << node << "," << tag << "," << tag2node << "," << connName << ")");
  ATH_MSG_WARNING("SqliteReadSvc::getQuery is a dummy method");
 
  return std::unique_ptr<IRDBQuery>();
}
 
std::string SqliteReadSvc::getChildTag(const std::string& childNode
                      , const std::string& parentTag
                      , const std::string& parentNode
                      , const std::string& )
{
  ATH_MSG_DEBUG("getChildTag for " << childNode << " " << parentTag << " " << parentNode);
  ATH_MSG_WARNING("SqliteReadSvc::getChildTag is a dummy method");
  return std::string();
}
 
void SqliteReadSvc::getTagDetails(RDBTagDetails& 
                                 , const std::string& tag
                                 , const std::string& )
{
  ATH_MSG_DEBUG("getTagDetails for tag: " << tag);
  ATH_MSG_WARNING("SqliteReadSvc::getTagDetails is a dummy method");
  return;
}