MuonCalib::CalibHeadOperations Class Reference

#include <CalibHeadOperations.h>

Collaboration diagram for MuonCalib::CalibHeadOperations:

Public Member Functions
	CalibHeadOperations (CalibDbConnection &db_conn)
virtual	~CalibHeadOperations ()
int	GetLatestHeadId ()
bool	GetHeadInfo (int &head_id, int &lowrun, int &uprun, int &lowtime, int &uptime)
CalibDbConnection *	GetDataConnection (int head_id=-1, bool write=false, const std::string &writer_connection="", const std::string &writer_user="", const std::string &writer_password="")

Private Attributes
CalibDbConnection *	m_meta_connection

Detailed Description

Definition at line 21 of file CalibHeadOperations.h.

Constructor & Destructor Documentation

CalibHeadOperations()

MuonCalib::CalibHeadOperations::CalibHeadOperations

(

CalibDbConnection &

db_conn

)

Definition at line 27 of file CalibHeadOperations.cxx.

: m_meta_connection(&db_conn) {}

~CalibHeadOperations()

MuonCalib::CalibHeadOperations::~CalibHeadOperations ( )

virtual

Definition at line 26 of file CalibHeadOperations.cxx.

{}

Member Function Documentation

GetDataConnection()

CalibDbConnection * MuonCalib::CalibHeadOperations::GetDataConnection	(	int	head_id = -1,
		bool	write = false,
		const std::string &	writer_connection = "",
		const std::string &	writer_user = "",
		const std::string &	writer_password = "" )

Definition at line 90 of file CalibHeadOperations.cxx.

                                                                                                                              {
        if (head_id < 0) { head_id = GetLatestHeadId(); }
        if (head_id < 0) return nullptr;
        try {
            m_meta_connection->OpenTransaction();
            coral::IQuery* query = m_meta_connection->GetQuery();
            query->setRowCacheSize(1);
            query->addToTableList("MDT_HEAD");
            query->addToTableList("MDT_DATA_SCHEMA");
            query->addToOutputList("MDT_DATA_SCHEMA.SCHEMA_NAME", "SCHEMA");
            query->addToOutputList("MDT_DATA_SCHEMA.WRITER_ACCOUNT", "WRITER_ACCOUNT");
            query->addToOutputList("MDT_DATA_SCHEMA.ACTIVE", "ACTIVE");
            query->addToOutputList("MDT_DATA_SCHEMA.ARCHIVED", "ARCHIVED");
            query->addToOutputList("MDT_DATA_SCHEMA.ARCHIVE_CONNECTION_STRING", "ARCHIVE_CONNECTION_STRING");
            std::string condition = "MDT_HEAD.DATA_SCHEMA=MDT_DATA_SCHEMA.SCHEMA_NAME and MDT_HEAD.HEAD_ID=:hid";
            coral::AttributeList conditionData;
            conditionData.extend<int>("hid");
            conditionData["hid"].data<int>() = head_id;
            query->setCondition(condition, conditionData);
            coral::ICursor& cursor = query->execute();
            if (!cursor.next()) {
                MsgStream log(Athena::getMessageSvc(), "CalibHeadOperations");
                log << MSG::WARNING << "No information about head_id=" << head_id << " found!" << endmsg;
                return nullptr;
            }
            const coral::AttributeList& al = cursor.currentRow();
            if (write && !al["ACTIVE"].data<bool>()) {
                MsgStream log(Athena::getMessageSvc(), "CalibHeadOperations");
                log << MSG::WARNING << "Can only write to the active schema" << endmsg;
                return nullptr;
            }
            if (al["ARCHIVED"].data<bool>()) {
                return new CalibDbConnection(al["ARCHIVE_CONNECTION_STRING"].data<std::string>(), al["SCHEMA"].data<std::string>());
            }
            if (!write) {
                CalibDbConnection* conn = new CalibDbConnection(m_meta_connection->GetConnectionString(), al["SCHEMA"].data<std::string>());
                std::string user, passwd;
                m_meta_connection->GetLogin(user, passwd);
                conn->SetLogin(user, passwd);
                return conn;
            }
            CalibDbConnection* ret = new CalibDbConnection(writer_connection, al["SCHEMA"].data<std::string>());
            ret->SetTargetUser(al["WRITER_ACCOUNT"].data<std::string>());
            ret->SetLogin(writer_user, writer_password);
            return ret;
        } catch (coral::SchemaException& e) {
            MsgStream log(Athena::getMessageSvc(), "CalibHeadOperations");
            log << MSG::WARNING << "Schema exception : " << e.what() << endmsg;
            return nullptr;
        }
    }

GetHeadInfo()

bool MuonCalib::CalibHeadOperations::GetHeadInfo	(	int &	head_id,
		int &	lowrun,
		int &	uprun,
		int &	lowtime,
		int &	uptime )

Definition at line 51 of file CalibHeadOperations.cxx.

                                                                                                          {
        if (head_id < 0) { head_id = GetLatestHeadId(); }
        if (head_id < 0) {
            MsgStream log(Athena::getMessageSvc(), "CalibHeadOperations");
            log << MSG::WARNING << "CalibHeadOperations::GetHeadInfo: Cannot get latest head id" << endmsg;
            return -1;
        }
        try {
            m_meta_connection->OpenTransaction();
            coral::IQuery* query = m_meta_connection->GetQuery();
            query->addToTableList("MDT_HEAD");
            query->addToOutputList("LOWRUN");
            query->addToOutputList("UPRUN");
            query->addToOutputList("LOWTIME");
            query->addToOutputList("UPTIME");
            std::string condition = "HEAD_ID=:hid";
            coral::AttributeList conditionData;
            conditionData.extend<int>("hid");
            conditionData["hid"].data<int>() = head_id;
            query->setCondition(condition, conditionData);
            coral::ICursor& cursor = query->execute();
            if (!cursor.next()) {
                MsgStream log(Athena::getMessageSvc(), "CalibHeadOperations");
                log << MSG::WARNING << "No information about head_id=" << head_id << " found!" << endmsg;
                return false;
            }
            const coral::AttributeList& al = cursor.currentRow();
            lowrun = al["LOWRUN"].data<int>();
            uprun = al["UPRUN"].data<int>();
            lowtime = al["LOWTIME"].data<int>();
            uptime = al["UPTIME"].data<int>();
            return true;
        } catch (coral::SchemaException& e) {
            MsgStream log(Athena::getMessageSvc(), "CalibHeadOperations");
            log << MSG::WARNING << "Schema exception : " << e.what() << endmsg;
            return false;
        }
    }

GetLatestHeadId()

int MuonCalib::CalibHeadOperations::GetLatestHeadId

(

)

Definition at line 29 of file CalibHeadOperations.cxx.

                                             {
        try {
            m_meta_connection->OpenTransaction();
            coral::IQuery* query = m_meta_connection->GetQuery();
            query->setRowCacheSize(1);
            query->addToTableList("MDT_HEAD");
            query->addToOutputList("max(HEAD_ID)", "max_head_id");
            coral::ICursor& cursor = query->execute();
            if (!cursor.next()) {
                MsgStream log(Athena::getMessageSvc(), "CalibHeadOperations");
                log << MSG::WARNING << "Query for head_id failed!" << endmsg;
                return -1;
            }
            const coral::AttributeList& al = cursor.currentRow();
            return static_cast<int>(al["max_head_id"].data<double>());
        } catch (coral::SchemaException& e) {
            MsgStream log(Athena::getMessageSvc(), "CalibHeadOperations");
            log << MSG::WARNING << "Schema exception : " << e.what() << endmsg;
            return -1;
        }
    }

Member Data Documentation

m_meta_connection

CalibDbConnection* MuonCalib::CalibHeadOperations::m_meta_connection

private

Definition at line 37 of file CalibHeadOperations.h.

---

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

• CalibHeadOperations.h
• CalibHeadOperations.cxx