cond::persistency::IOVProxy Class Reference

#include <IOVProxy.h>

Public Member Functions
cond::Iov_t	getInterval (cond::Time_t time)
cond::Iov_t	getInterval (cond::Time_t time, cond::Time_t defaultIovSize)
cond::Iov_t	getLast ()
std::tuple< std::string, boost::posix_time::ptime, boost::posix_time::ptime >	getMetadata () const
	IOVProxy ()
	IOVProxy (const IOVProxy &rhs)
	IOVProxy (const std::shared_ptr< SessionImpl > &session)
cond::TagInfo_t	iovSequenceInfo () const
void	load (const std::string &tag)
void	load (const std::string &tag, const boost::posix_time::ptime &snapshottime)
std::pair< cond::Time_t, cond::Time_t >	loadedGroup () const
int	loadedSize () const
size_t	numberOfQueries () const
IOVProxy &	operator= (const IOVProxy &rhs)
void	reset ()
IOVArray	selectAll ()
IOVArray	selectAll (const boost::posix_time::ptime &snapshottime)
IOVArray	selectRange (const cond::Time_t &begin, const cond::Time_t &end)
IOVArray	selectRange (const cond::Time_t &begin, const cond::Time_t &end, const boost::posix_time::ptime &snapshottime)
bool	selectRange (const cond::Time_t &begin, const cond::Time_t &end, IOVContainer &destination)
int	sequenceSize () const
const std::shared_ptr< SessionImpl > &	session () const
cond::Tag_t	tagInfo () const

Private Member Functions
void	checkTransaction (const std::string &ctx) const
void	fetchSequence (cond::Time_t lowerGroup, cond::Time_t higherGroup)
void	loadGroups ()
void	resetIOVCache ()

Private Attributes
std::shared_ptr< IOVProxyData >	m_data
std::shared_ptr< SessionImpl >	m_session

Detailed Description

Definition at line 92 of file IOVProxy.h.

Constructor & Destructor Documentation

IOVProxy() [1/3]

IOVProxy::IOVProxy

(

)

Definition at line 119 of file IOVProxy.cc.

: m_data(), m_session() {}

IOVProxy() [2/3]

IOVProxy::IOVProxy ( const std::shared_ptr< SessionImpl > &  session )

explicit

Definition at line 121 of file IOVProxy.cc.

: m_data(new IOVProxyData), m_session(session) {}

IOVProxy() [3/3]

IOVProxy::IOVProxy

(

const IOVProxy &

rhs

)

Definition at line 123 of file IOVProxy.cc.

: m_data(rhs.m_data), m_session(rhs.m_session) {}

Member Function Documentation

checkTransaction()

void IOVProxy::checkTransaction ( const std::string &  ctx ) const

private

Definition at line 285 of file IOVProxy.cc.

                                                              {
      if (!m_session.get())
        throwException("The session is not active.", ctx);
      if (!m_session->isTransactionActive(false))
        throwException("The transaction is not active.", ctx);
    }

References m_session, and cond::persistency::throwException().

Referenced by getInterval(), getLast(), getMetadata(), iovSequenceInfo(), load(), selectAll(), selectRange(), and sequenceSize().

fetchSequence()

void IOVProxy::fetchSequence ( cond::Time_t  lowerGroup, cond::Time_t  higherGroup  )

private

Definition at line 292 of file IOVProxy.cc.

                                                                              {
      m_data->iovSequence.clear();
      m_session->iovSchema().iovTable().select(
          m_data->tagInfo.name, lowerGroup, higherGroup, m_data->snapshotTime, m_data->iovSequence);
 
      if (m_data->iovSequence.empty()) {
        m_data->groupLowerIov = cond::time::MAX_VAL;
        m_data->groupHigherIov = cond::time::MIN_VAL;
      } else {
        if (lowerGroup > cond::time::MIN_VAL) {
          m_data->groupLowerIov = std::get<0>(m_data->iovSequence.front());
        } else {
          m_data->groupLowerIov = cond::time::MIN_VAL;
        }
        m_data->groupHigherIov = std::get<0>(m_data->iovSequence.back());
        if (higherGroup < cond::time::MAX_VAL) {
          m_data->groupHigherIov = cond::time::tillTimeFromNextSince(higherGroup, m_data->tagInfo.timeType);
        } else {
          m_data->groupHigherIov = cond::time::MAX_VAL;
        }
      }
 
      m_data->numberOfQueries++;
    }

References m_data, m_session, cond::time::MAX_VAL(), cond::time::MIN_VAL(), and cond::time::tillTimeFromNextSince().

Referenced by getInterval().

getInterval() [1/2]

cond::Iov_t IOVProxy::getInterval

(

cond::Time_t

time

)

Definition at line 317 of file IOVProxy.cc.

{ return getInterval(time, cond::time::MAX_VAL); }

References cond::time::MAX_VAL(), and ntuplemaker::time.

Referenced by popcon::PopConBTransitionSourceHandler< T >::checkBOn(), popcon::PopConESTransitionSourceHandler< T >::checkLowGain(), popcon::PopConBTransitionSourceHandler< T >::getObjectsForBTransition(), popcon::PopConESTransitionSourceHandler< T >::getObjectsForESTransition(), and cond::service::OnlineDBOutputService::preLoadIov().

getInterval() [2/2]

cond::Iov_t IOVProxy::getInterval	(	cond::Time_t	time,
		cond::Time_t	defaultIovSize
	)

Definition at line 319 of file IOVProxy.cc.

                                                                              {
      if (!m_data.get())
        throwException("No tag has been loaded.", "IOVProxy::getInterval");
      checkTransaction("IOVProxy::getInterval");
      if (!m_data->cacheInitialized)
        loadGroups();
      cond::Iov_t retVal;
      // organize iovs in pages...
      // first check the available iov cache:
      if (m_data->groupLowerIov == cond::time::MAX_VAL ||  // case 0 : empty cache ( the first request )
          time < m_data->groupLowerIov || time >= m_data->groupHigherIov) {  // case 1 : target outside
 
        // a new query required!
        // first determine the groups
        auto iGLow = search(time, m_data->sinceGroups);
        if (iGLow == m_data->sinceGroups.end()) {
          // no suitable group=no iov at all! exiting...
          return retVal;
        }
        auto iGHigh = iGLow;
        cond::Time_t lowG = *iGLow;
        iGHigh++;
        cond::Time_t highG = cond::time::MAX_VAL;
        if (iGHigh != m_data->sinceGroups.end())
          highG = *iGHigh;
 
        // finally, get the iovs for the selected group interval!!
        fetchSequence(lowG, highG);
      }
 
      // the current iov set is a good one...
      auto iIov = search(time, m_data->iovSequence);
      if (iIov == m_data->iovSequence.end()) {
        return retVal;
      }
 
      retVal.since = std::get<0>(*iIov);
      auto next = iIov;
      next++;
 
      // default is the end of validity when set...
      retVal.till = m_data->tagInfo.endOfValidity;
      // for the till, the next element of the sequence has to be looked up
      cond::Time_t tillVal;
      if (next != m_data->iovSequence.end()) {
        tillVal = cond::time::tillTimeFromNextSince(std::get<0>(*next), m_data->tagInfo.timeType);
      } else {
        tillVal = m_data->groupHigherIov;
      }
      if (tillVal < retVal.till)
        retVal.till = tillVal;
      //
      retVal.payloadId = std::get<1>(*iIov);
      if (retVal.till == cond::time::MAX_VAL && defaultIovSize != cond::time::MAX_VAL) {
        if (defaultIovSize == 0) {
          // ???? why?
          retVal.clear();
        } else {
          retVal.since = time;
          retVal.till = retVal.since + defaultIovSize - 1;
          if (time > retVal.till)
            retVal.till = time;
        }
      }
      return retVal;
    }

References checkTransaction(), cond::Iov_t::clear(), fetchSequence(), loadGroups(), m_data, cond::time::MAX_VAL(), GetRecoTauVFromDQM_MC_cff::next, cond::Iov_t::payloadId, cond::persistency::search(), cond::Iov_t::since, cond::persistency::throwException(), cond::Iov_t::till, cond::time::tillTimeFromNextSince(), and ntuplemaker::time.

getLast()

cond::Iov_t IOVProxy::getLast

(

)

Definition at line 386 of file IOVProxy.cc.

                                {
      checkTransaction("IOVProxy::getLast");
      cond::Iov_t ret;
      bool ok = m_session->iovSchema().iovTable().getLastIov(
          m_data->tagInfo.name, m_data->snapshotTime, ret.since, ret.payloadId);
      if (ok) {
        setTillToLastIov(ret, m_data->tagInfo.endOfValidity);
      }
      return ret;
    }

References checkTransaction(), m_data, m_session, convertSQLiteXML::ok, runTheMatrix::ret, and cond::persistency::setTillToLastIov().

Referenced by SiStripDetVOffHandler::analyze(), SiStripPayloadHandler< SiStripPayload >::analyze(), cond::service::PoolDBOutputService::getTagInfo(), and popcon::PopCon::initialize().

getMetadata()

std::tuple< std::string, boost::posix_time::ptime, boost::posix_time::ptime > IOVProxy::getMetadata

(

)

const

Definition at line 272 of file IOVProxy.cc.

                                                                                                {
      if (!m_data.get())
        throwException("No tag has been loaded.", "IOVProxy::getMetadata");
      checkTransaction("IOVProxy::getMetadata");
      std::tuple<std::string, boost::posix_time::ptime, boost::posix_time::ptime> ret;
      if (!m_session->iovSchema().tagTable().getMetadata(
              m_data->tagInfo.name, std::get<0>(ret), std::get<1>(ret), std::get<2>(ret))) {
        throwException("Metadata for tag \"" + m_data->tagInfo.name + "\" have not been found in the database.",
                       "IOVProxy::getMetadata");
      }
      return ret;
    }

References checkTransaction(), m_data, m_session, runTheMatrix::ret, and cond::persistency::throwException().

iovSequenceInfo()

cond::TagInfo_t IOVProxy::iovSequenceInfo

(

)

const

Definition at line 257 of file IOVProxy.cc.

                                                  {
      if (!m_data.get())
        throwException("No tag has been loaded.", "IOVProxy::iovSequenceInfo");
      checkTransaction("IOVProxy::iovSequenceInfo");
      cond::TagInfo_t ret;
      m_session->iovSchema().iovTable().getSize(m_data->tagInfo.name, m_data->snapshotTime, ret.size);
      cond::Iov_t last;
      bool ok = m_session->iovSchema().iovTable().getLastIov(
          m_data->tagInfo.name, m_data->snapshotTime, ret.lastInterval.since, ret.lastInterval.payloadId);
      if (ok) {
        setTillToLastIov(ret.lastInterval, m_data->tagInfo.endOfValidity);
      }
      return ret;
    }

References checkTransaction(), dqmdumpme::last, m_data, m_session, convertSQLiteXML::ok, runTheMatrix::ret, cond::persistency::setTillToLastIov(), and cond::persistency::throwException().

load() [1/2]

void IOVProxy::load

(

const std::string &

tag

)

Definition at line 131 of file IOVProxy.cc.

                                                {
      boost::posix_time::ptime notime;
      load(tagName, notime);
    }

References JetPartonCorrections_cff::tagName.

Referenced by MatrixToProcess.MatrixToProcess::getProcess(), MatrixToProcess.MatrixToProcess::listAll(), ConfigBuilder.ConfigBuilder::prepare_FILTER(), and cond::persistency::Session::readIov().

load() [2/2]

void IOVProxy::load	(	const std::string &	tag,
		const boost::posix_time::ptime &	snapshottime
	)

Definition at line 136 of file IOVProxy.cc.

                                                                                          {
      if (!m_data.get())
        return;
 
      // clear
      reset();
 
      checkTransaction("IOVProxyNew::load");
 
      if (!m_session->iovSchema().tagTable().select(tagName,
                                                    m_data->tagInfo.timeType,
                                                    m_data->tagInfo.payloadType,
                                                    m_data->tagInfo.synchronizationType,
                                                    m_data->tagInfo.endOfValidity,
                                                    m_data->tagInfo.lastValidatedTime)) {
        throwException("Tag \"" + tagName + "\" has not been found in the database.", "IOVProxy::load");
      }
      m_data->tagInfo.name = tagName;
      m_data->snapshotTime = snapshotTime;
    }

References checkTransaction(), m_data, m_session, reset(), loadRecoTauTagMVAsFromPrepDB_cfi::snapshotTime, JetPartonCorrections_cff::tagName, and cond::persistency::throwException().

Referenced by MatrixToProcess.MatrixToProcess::getProcess(), MatrixToProcess.MatrixToProcess::listAll(), and ConfigBuilder.ConfigBuilder::prepare_FILTER().

loadedGroup()

std::pair< cond::Time_t, cond::Time_t > IOVProxy::loadedGroup

(

)

const

Definition at line 409 of file IOVProxy.cc.

                                                                {
      return m_data.get() ? std::make_pair(m_data->groupLowerIov, m_data->groupHigherIov)
                          : std::make_pair(cond::time::MAX_VAL, cond::time::MIN_VAL);
    }

References m_data, cond::time::MAX_VAL(), and cond::time::MIN_VAL().

loadedSize()

int IOVProxy::loadedSize

(

)

const

Definition at line 397 of file IOVProxy.cc.

{ return m_data.get() ? m_data->iovSequence.size() : 0; }

References m_data.

Referenced by popcon::PopConBTransitionSourceHandler< T >::checkBOn(), popcon::PopConESTransitionSourceHandler< T >::checkLowGain(), popcon::PopConBTransitionSourceHandler< T >::getObjectsForBTransition(), and popcon::PopConESTransitionSourceHandler< T >::getObjectsForESTransition().

loadGroups()

void IOVProxy::loadGroups ( )

private

Definition at line 157 of file IOVProxy.cc.

                              {
      //if( !m_data.get() ) return;
 
      // clear
      resetIOVCache();
 
      //checkTransaction( "IOVProxyNew::load" );
      m_session->iovSchema().iovTable().getGroups(m_data->tagInfo.name,
                                                  m_data->snapshotTime,
                                                  cond::time::sinceGroupSize(m_data->tagInfo.timeType),
                                                  m_data->sinceGroups);
      m_data->cacheInitialized = true;
    }

References m_data, m_session, resetIOVCache(), and cond::time::sinceGroupSize().

Referenced by getInterval().

numberOfQueries()

size_t IOVProxy::numberOfQueries

(

)

const

Definition at line 407 of file IOVProxy.cc.

{ return m_data.get() ? m_data->numberOfQueries : 0; }

References m_data.

operator=()

IOVProxy & IOVProxy::operator=

(

const IOVProxy &

rhs

)

Definition at line 125 of file IOVProxy.cc.

                                                     {
      m_data = rhs.m_data;
      m_session = rhs.m_session;
      return *this;
    }

References m_data, and m_session.

reset()

void IOVProxy::reset

(

void

)

Definition at line 236 of file IOVProxy.cc.

                         {
      if (m_data.get()) {
        m_data->tagInfo.clear();
      }
      resetIOVCache();
    }

References m_data, and resetIOVCache().

Referenced by MatrixReader.MatrixReader::__init__(), load(), data_sources.json_list::next(), and MatrixReader.MatrixReader::showRaw().

resetIOVCache()

void IOVProxy::resetIOVCache ( )

private

Definition at line 226 of file IOVProxy.cc.

                                 {
      if (m_data.get()) {
        m_data->groupLowerIov = cond::time::MAX_VAL;
        m_data->groupHigherIov = cond::time::MIN_VAL;
        m_data->sinceGroups.clear();
        m_data->iovSequence.clear();
        m_data->numberOfQueries = 0;
      }
    }

References m_data, cond::time::MAX_VAL(), and cond::time::MIN_VAL().

Referenced by loadGroups(), and reset().

selectAll() [1/2]

IOVArray IOVProxy::selectAll

(

)

Definition at line 171 of file IOVProxy.cc.

                                 {
      boost::posix_time::ptime no_time;
      return selectAll(no_time);
    }

Referenced by SiStripDetVOffTkMapPlotter::analyze(), SiStripDetVOffPrinter::analyze(), SiStripDetVOffTrendPlotter::analyze(), BeamSpotRcdPrinter::analyze(), RunInfoUpdate::import(), cond::persistency::KeyList::loadFromDB(), l1t::DataWriterExt::payloadToken(), l1t::DataWriter::payloadToken(), and cond::persistency::KeyList::setKeys().

selectAll() [2/2]

IOVArray IOVProxy::selectAll

(

const boost::posix_time::ptime &

snapshottime

)

Definition at line 176 of file IOVProxy.cc.

                                                                         {
      if (!m_data.get())
        throwException("No tag has been loaded.", "IOVProxy::selectAll");
      checkTransaction("IOVProxy::selectAll");
      IOVArray ret;
      ret.m_tagInfo = m_data->tagInfo;
      m_session->iovSchema().iovTable().select(
          m_data->tagInfo.name, cond::time::MIN_VAL, cond::time::MAX_VAL, snapshottime, *ret.m_array);
      return ret;
    }

References checkTransaction(), m_data, m_session, cond::time::MAX_VAL(), cond::time::MIN_VAL(), runTheMatrix::ret, and cond::persistency::throwException().

selectRange() [1/3]

IOVArray IOVProxy::selectRange	(	const cond::Time_t &	begin,
		const cond::Time_t &	end
	)

Definition at line 187 of file IOVProxy.cc.

                                                                                 {
      boost::posix_time::ptime no_time;
      return selectRange(begin, end, no_time);
    }

References begin, and end.

Referenced by cond::payloadInspector::PlotBase::exec_process().

selectRange() [2/3]

IOVArray IOVProxy::selectRange	(	const cond::Time_t &	begin,
		const cond::Time_t &	end,
		const boost::posix_time::ptime &	snapshottime
	)

Definition at line 192 of file IOVProxy.cc.

                                                                             {
      if (!m_data.get())
        throwException("No tag has been loaded.", "IOVProxy::selectRange");
 
      checkTransaction("IOVProxy::selectRange");
 
      IOVArray ret;
      ret.m_tagInfo = m_data->tagInfo;
      m_session->iovSchema().iovTable().getRange(m_data->tagInfo.name, begin, end, snapshotTime, *ret.m_array);
      return ret;
    }

References begin, checkTransaction(), end, m_data, m_session, runTheMatrix::ret, loadRecoTauTagMVAsFromPrepDB_cfi::snapshotTime, and cond::persistency::throwException().

selectRange() [3/3]

bool IOVProxy::selectRange	(	const cond::Time_t &	begin,
		const cond::Time_t &	end,
		IOVContainer &	destination
	)

Definition at line 206 of file IOVProxy.cc.

                                                                                                        {
      if (!m_data.get())
        throwException("No tag has been loaded.", "IOVProxy::selectRange");
 
      checkTransaction("IOVProxy::selectRange");
 
      boost::posix_time::ptime no_time;
      size_t prevSize = destination.size();
      m_session->iovSchema().iovTable().getRange(m_data->tagInfo.name, begin, end, no_time, destination);
      size_t niov = destination.size() - prevSize;
      return niov > 0;
    }

References begin, checkTransaction(), HLTMuonOfflineAnalyzer_cff::destination, end, m_data, m_session, and cond::persistency::throwException().

sequenceSize()

int IOVProxy::sequenceSize

(

)

const

Definition at line 399 of file IOVProxy.cc.

                                     {
      checkTransaction("IOVProxy::sequenceSize");
      size_t ret = 0;
      m_session->iovSchema().iovTable().getSize(m_data->tagInfo.name, m_data->snapshotTime, ret);
 
      return ret;
    }

References checkTransaction(), m_data, m_session, and runTheMatrix::ret.

Referenced by popcon::PopCon::initialize().

session()

const std::shared_ptr< SessionImpl > & IOVProxy::session

(

)

const

Definition at line 414 of file IOVProxy.cc.

{ return m_session; }

References m_session.

Referenced by cond::persistency::KeyList::loadFromDB(), and cond::persistency::KeyList::setKeys().

tagInfo()

cond::Tag_t IOVProxy::tagInfo

(

)

const

Definition at line 243 of file IOVProxy.cc.

{ return m_data.get() ? m_data->tagInfo : cond::Tag_t(); }

References m_data.

Referenced by popcon::PopConBTransitionSourceHandler< T >::getObjectsForBTransition(), popcon::PopConESTransitionSourceHandler< T >::getObjectsForESTransition(), cond::payloadInspector::PlotBase::getTagInfo(), and cond::DataProxyWrapperBase::timeType().

Member Data Documentation

m_data

std::shared_ptr<IOVProxyData> cond::persistency::IOVProxy::m_data

private

Definition at line 164 of file IOVProxy.h.

Referenced by fetchSequence(), getInterval(), getLast(), getMetadata(), iovSequenceInfo(), load(), loadedGroup(), loadedSize(), loadGroups(), numberOfQueries(), operator=(), reset(), resetIOVCache(), selectAll(), selectRange(), sequenceSize(), and tagInfo().

m_session

std::shared_ptr<SessionImpl> cond::persistency::IOVProxy::m_session

private

Definition at line 165 of file IOVProxy.h.

Referenced by checkTransaction(), fetchSequence(), getLast(), getMetadata(), iovSequenceInfo(), load(), loadGroups(), operator=(), selectAll(), selectRange(), sequenceSize(), and session().