DbiValidityRecBuilder.cxx

Go to the documentation of this file.

// $Id: DbiValidityRecBuilder.cxx,v 1.34 2009/03/12 08:49:05 nwest Exp $

#include "Conventions/Detector.h"
#include "Conventions/SimFlag.h"
#include "DatabaseInterface/DbiDBProxy.h"
#include "DatabaseInterface/DbiResultNonAgg.h"
#include "DatabaseInterface/DbiResultSet.h"
#include "DatabaseInterface/DbiSimFlagAssociation.h"
#include "DatabaseInterface/DbiValidityRec.h"
#include "DatabaseInterface/DbiValidityRecBuilder.h"
#include "LeakChecker/Lea.h"
#include "MessageService/MsgService.h"
#include "Validity/VldContext.h"

ClassImp(DbiValidityRecBuilder)

//   Definition of static data members
//   *********************************

CVSID("$Id: DbiValidityRecBuilder.cxx,v 1.34 2009/03/12 08:49:05 nwest Exp $");

//    Definition of all member functions (static or otherwise)
//    *******************************************************
//
//    -  ordered: ctors, dtor, operators then in alphabetical order.

//.....................................................................

DbiValidityRecBuilder::DbiValidityRecBuilder(const DbiDBProxy& proxy,
                                             const VldContext& vc, 
                                             const Dbi::Task& task,
                                             Int_t selectDbNo     /* Default: -1 */,
                                             Bool_t findFullTimeWindow /* Default: true*/
                                             ):
fIsExtendedContext(kFALSE),
fTask(task)
{
//
//  Purpose:  Constructor for specific context queries.
//
//  Arguments:  
//    proxy        in    Database proxy for this table.
//    vc           in    The Validity Context for the query.
//    task         in    The task of the query.
//    selectDbNo   in    If >=0 only look in selected DB.
//    findFullTimeWindow
//                 in    Attempt to find full validity of query 
//                        i.e beyond Dbi::GetTimeGate
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Create ValidityRecBuilder by applying a validity query to
//    the database table and building a set of DbiValidityRec
//    objects from the resulting DbiResultSet.
//
// o  Try each member of the cascade in turn until a query succeeds or the 
//    cascade is exhausted.
//
// o  For each member of the cascade try each associated SimFlag in turn 
//    until a query succeeds or the list of associated SimFlags is exhausted.


//  Program Notes:-
//  =============

//  None.

  LEA_CTOR    //Leak Checker

  MSG("Dbi", Msg::kVerbose) << "Creating DbiValidityRecBuilder" << endl;

  Detector::Detector_t     det(vc.GetDetector());
  SimFlag::SimFlag_t       sim(vc.GetSimFlag());
  VldTimeStamp             ts(vc.GetTimeStamp());
  SimFlag::SimFlag_t       simTry(sim);
  const string& tableName = proxy.GetTableName();
  Int_t sumTimeWindows = 0;
  Int_t numTimeWindows = 0;

//  Contruct a default (gap) validity record fGap.
//  If findFullTimeWindow then gap will be unlimited but will be trimmed
//  after each query.

  this->MakeGapRec(vc, tableName, findFullTimeWindow);

//  Force aggregate -1 into first slot.
  this->AddNewGap(-1);

  const VldTimeStamp curVTS = vc.GetTimeStamp();

// Check to see if table exists.

  unsigned int numVRecIn = 0;

  if ( ! proxy.TableExists() ) {
    MAXMSG("Dbi", Msg::kWarning,10) 
         << "DbiValidityRecBuilder::Query for table:" 
         << proxy.GetTableName() 
         << ", table does not exist!" << endl;
  }

  else {
    
//  Loop over all databases in cascade until valid data found.

    UInt_t numDb     = proxy.GetNumDb();
    Bool_t foundData = kFALSE;

    for ( UInt_t dbNo = 0; dbNo < numDb && ! foundData; ++dbNo ) {

      // Skip if cascade entry does not have this table or selection in force and not the required one.
      if ( ! proxy.TableExists(dbNo) ) continue;
      if ( selectDbNo >= 0 && selectDbNo != (int) dbNo ) continue;

//    Loop over all associated SimFlags.

      DbiSimFlagAssociation::SimList_t simList 
                    = DbiSimFlagAssociation::Instance().Get(sim);

      DbiSimFlagAssociation::SimList_t::iterator listItr    = simList.begin();
      DbiSimFlagAssociation::SimList_t::iterator listItrEnd = simList.end();
      while ( listItr !=  listItrEnd && ! foundData ) {

        simTry = *listItr;
        ++listItr;
        VldContext vcTry(det,simTry,ts);

//      Apply validity query and build result set.

        DbiResultSet* rs = proxy.QueryValidity(vcTry,fTask,dbNo);

//      Build a result from the result set and drop result set.

        DbiValidityRec tr;
        DbiResultNonAgg result(rs,&tr,0,kFALSE);
        delete rs;

//      Loop over all entries in DbiResult and, for each Aggregate, 
//      find effective validity range of best, or of gap if none.

//      Set earliest creation date to infinite past - the right value if in a gap.
        VldTimeStamp earliestCreate(0);
        UInt_t numRows = result.GetNumRows();
        for (UInt_t row = 0; row < numRows; ++row) {
          const DbiValidityRec* vr = dynamic_cast<const DbiValidityRec*>(
                                            result.GetTableRow(row));

          Int_t aggNo = vr->GetAggregateNo();
      
//        If starting a new aggregate prime it as a gap.
          Int_t index = this->IndexOfAggno(aggNo);
          if ( index < 0 ) index = this->AddNewGap(aggNo);

//        Trim the validity record for the current aggregate
//        number by this record and see if we have found valid
//        data yet.
  
          DbiValidityRec& curRec = fVRecs[index];
          curRec.Trim(curVTS, *vr);
          if ( ! curRec.IsGap() ) {
            foundData = kTRUE;

//          Fill in entry's database number - its not stored in the 
//          database table!
            curRec.SetDbNo(dbNo);
          }

//        Find the earliest non-gap creation date that is used
          if (     curRec.GetSeqNo() ==   vr->GetSeqNo()
                   &&  (    earliestCreate > vr->GetCreationDate() 
                         || earliestCreate.GetSec() == 0 )
             ) earliestCreate = vr->GetCreationDate();

//        Count the number used and sum the time windows
          ++numVRecIn;
          const VldRange range = vr->GetVldRange();
          Int_t timeInterval =   range.GetTimeEnd().GetSec() 
                               - range.GetTimeStart().GetSec();
          if ( timeInterval < 5 ) {
            MAXMSG("Dbi",Msg::kWarning,20) 
            << "Detected suspiciously small validity time interval in \n"
            << "table " << tableName << " validity rec " << *vr << endl;
          }
          sumTimeWindows += timeInterval;
          ++numTimeWindows;
        }

//      If finding findFullTimeWindow then find bounding limits 
//      for the cascade and sim flag and trim all validity records
//      and the default (gap) validity record.
        if ( findFullTimeWindow ) {
          VldTimeStamp start, end;
          proxy.FindTimeBoundaries(vcTry,fTask,dbNo,earliestCreate,start,end);
          MSGSTREAM("Dbi",Msg::kDebug) << "Trimming validity records to " 
                                      << start << " .. " << end << endl;
          std::vector<DbiValidityRec>::iterator itr(fVRecs.begin()), itrEnd(fVRecs.end());
          for( ; itr != itrEnd; ++itr ) itr->AndTimeWindow(start,end);
          fGap.AndTimeWindow(start,end);
        }
      }

    }
  }

//  If the query found no records in any database then
//  the tables will still have something - the aggno = -1 gap

// If the associated SimFlag is different to the original request make
// sure that all the DbiValidityRec are valid for the request.
  if ( sim != simTry ) {
    MSG("Dbi",Msg::kSynopsis) << "Imposing SimFlag of " << sim << " on DbiValidityRecs which matched " << simTry << endl; 
    for ( unsigned int irec = 0; irec < GetNumValidityRec(); ++irec ) {
      DbiValidityRec& vrec = const_cast<DbiValidityRec&>(GetValidityRec(irec));
      const VldRange& vr(vrec.GetVldRange());
      VldRange vr_mod(vr.GetDetectorMask(),sim,vr.GetTimeStart(),vr.GetTimeEnd(),vr.GetDataSource());
      vrec.SetVldRange(vr_mod);
    }
  }

  MsgStream& msg =  MSGSTREAM("Dbi",Msg::kSynopsis);
  msg << "DbiValidityRecBuilder:" << endl 
      << " Query: " << vc.AsString() << endl
      << " using associated SimFlag: " << SimFlag::AsString(simTry)
      << " for " << SimFlag::AsString(sim)
      << " found " << numVRecIn 
      << " vrecs in database, for " << fVRecs.size()
      << " aggregates:-." << endl;

  for ( unsigned int irec = 0; irec < GetNumValidityRec(); ++irec ) {
    const DbiValidityRec& vrec = GetValidityRec(irec);
    if ( vrec.GetAggregateNo() != -2 
         )   msg << " " << irec << " " << GetValidityRec(irec) << endl;
  }



// Adjust the time gate if grossly wrong.
  if ( numTimeWindows > 0 ) {
    Int_t timeGateCalc = 3 * fVRecs.size() * sumTimeWindows/numTimeWindows;
    // Limit to 100 days and allow for overflow.
    if ( timeGateCalc > 100*24*60*60 || timeGateCalc < 0 
       ) timeGateCalc = 100*24*60*60;
    Int_t timeGateCurr = Dbi::GetTimeGate(tableName);
    if (    timeGateCurr < timeGateCalc/10 
         || timeGateCurr > timeGateCalc*10 
            ) {
      Dbi::SetTimeGate(tableName,timeGateCalc);
      if ( timeGateCalc != Dbi::GetTimeGate(tableName) ) {
        MAXMSG("Dbi",Msg::kWarning,20) 
          << "The ignored time gate setting was calculated with the following data:-" 
          << "\n   Context: " << vc << " task " << task  << " findFullTimeWindow " << findFullTimeWindow
          << "\n   Number of vrecs " << numTimeWindows 
          << " total time (secs) of all vrecs " << sumTimeWindows
          << " Number of aggregates " << fVRecs.size() << endl;
      }
    }
  }

  return;

}

//.....................................................................

DbiValidityRecBuilder::DbiValidityRecBuilder(const DbiDBProxy& proxy,
                                             const string& context,
                                             const Dbi::Task& task):
fIsExtendedContext(kTRUE),
fTask(task)
{
//
//  Purpose:  Constructor for extended context queries.
//
//  Arguments:  
//    proxy        in    Database proxy for this table.
//    context      in    The SQL corresponding to the extended context for the query.
//    task         in    The task of the query.
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Create ValidityRecBuilder by applying a validity query to
//    the database table and building a set of DbiValidityRec
//    objects from the resulting DbiResultSet.


//  Program Notes:-
//  =============

//  None.

  LEA_CTOR    //Leak Checker

  MSG("Dbi", Msg::kVerbose) << "Creating DbiValidityRecBuilder" 
                            << " for extended context " << context << endl;

// Prime fVRecs with a gap that will not be used but makes the result
// look like an aggregated result.

  MSG("Dbi", Msg::kVerbose) << "Initialising with gap record " << fGap << endl;
  this->AddNewGap(-1);

// Check to see if table exists.

  unsigned int numVRecIn = 0;

  if ( ! proxy.TableExists() ) {
    MSG("Dbi", Msg::kWarning) 
         << "DbiValidityRecBuilder::Query for table:" 
         << proxy.GetTableName() 
         << ", table does not exist!" << endl;
  }

  else if ( context == "" ) {
    MSG("Dbi", Msg::kWarning) 
         << "DbiValidityRecBuilder::Null query for table:" 
         << proxy.GetTableName() << endl;
  }

  else {
    
//  Loop over all databases in cascade until valid data found.

    UInt_t numDb     = proxy.GetNumDb();
    Bool_t foundData = kFALSE;
 
    for ( UInt_t dbNo = 0; dbNo < numDb && ! foundData; ++dbNo ) {

//    Apply validity query and build result set.

      DbiResultSet* rs = proxy.QueryValidity(context,fTask,dbNo);

//    Build a result from the result set and drop result set.

      DbiValidityRec tr;
      DbiResultNonAgg result(rs,&tr,0,kFALSE);
      delete rs;

//    Loop over all entries in DbiResult and add them all to set.

      UInt_t numRows = result.GetNumRows();
      for (UInt_t row = 0; row < numRows; ++row) {
        const DbiValidityRec* vr = dynamic_cast<const DbiValidityRec*>(
                                          result.GetTableRow(row));
        
//      Cannot use AddNewAgg - aggregate numbers may be duplicated.
        Int_t index = fVRecs.size();
        fVRecs.push_back(DbiValidityRec(*vr));
        fAggNoToIndex[vr->GetAggregateNo()] = index;
        foundData = kTRUE;
        
//      Fill in entry's database number - its not stored in the 
//      database table!
        fVRecs[index].SetDbNo(dbNo);

//      Count the number used.
        ++numVRecIn;
      }
    }
  }

  MsgStream& msg =  MSGSTREAM("Dbi",Msg::kSynopsis);
  msg << "DbiValidityRecBuilder:" << endl 
      << " Extended context query: " << context << endl
      << " found " << numVRecIn 
      << " vrecs in database, for " << fVRecs.size()
      << " records:-." << endl;

  for ( unsigned int irec = 0; irec < GetNumValidityRec(); ++irec ) {
    msg << " " << irec << " " << GetValidityRec(irec) << endl;
  }
  return;


  
}

//.....................................................................

DbiValidityRecBuilder::DbiValidityRecBuilder(const DbiValidityRec& vr,
                                             const std::string tableName):
fIsExtendedContext(kFALSE),
fTask(vr.GetTask())
{
//
//  Purpose:  Constructor for an existing query result.
//
//  Arguments:  
//    vr           in    The DbiValidityRec from the query.
//    tableName    in    The name of the table that satisfied the query 

  LEA_CTOR    //Leak Checker

  MSG("Dbi", Msg::kVerbose) << "Creating DbiValidityRecBuilder" << endl;

  const VldRange&          vrange(vr.GetVldRange());
  // This is the only way I can find to handle Detector and SimFlag!
  VldContext vc( (Detector::Detector_t) vrange.GetDetectorMask(),
                 (SimFlag::SimFlag_t) vrange.GetSimMask(),
                 vrange.GetTimeStart());
  this->MakeGapRec(vc,tableName);
  this->AddNewAgg(vr,vr.GetAggregateNo());

}
//.....................................................................

DbiValidityRecBuilder::~DbiValidityRecBuilder() {
//
//
//  Purpose: Destructor
//
//  Arguments: 
//    None.
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Destroy ValidityRecBuilder.


//  Program Notes:-
//  =============

//  None.

  LEA_DTOR    //Leak Checker

  MSG("Dbi", Msg::kVerbose)
    << "Destroying DbiValidityRecBuilder" << endl;

}

//.....................................................................

std::string DbiValidityRecBuilder::GetL2CacheName() const {
//
//
//  Purpose:  Return the associated Level 2 Cache Name.
//
//  Specification:-
//  =============
//
//  o For format see static DbiValidityRec::GetL2CacheName.
//
//  Gaps are excluded (and if all are gaps the returned name is empty).


// Extended Context queries are not L2 cached.
  if ( this->IsExtendedContext() ) return "";

  UInt_t seqLo = 0;
  UInt_t seqHi = 0;
  VldTimeStamp ts;
  std::vector<DbiValidityRec>::const_iterator itr = fVRecs.begin();
  std::vector<DbiValidityRec>::const_iterator end = fVRecs.end();
  
  for (; itr != end; ++itr) {
    const DbiValidityRec& vr = *itr;
    if ( ! vr.IsGap() ) {
      if ( seqLo == 0 ) {
        seqLo = vr.GetSeqNo();
        seqHi = vr.GetSeqNo();
        ts    = vr.GetCreationDate();
      }
      else {
        if ( seqLo < vr.GetSeqNo() )        seqLo = vr.GetSeqNo();
        if ( seqHi > vr.GetSeqNo() )        seqHi = vr.GetSeqNo();
        if ( ts    < vr.GetCreationDate() ) ts    = vr.GetCreationDate(); 
      }
    }
  }

  if ( seqLo == 0 ) return "";
  
  return DbiValidityRec::GetL2CacheName(seqLo,seqHi,ts);

}
  
//.....................................................................

UInt_t DbiValidityRecBuilder::AddNewAgg(const DbiValidityRec& vrec,Int_t aggNo) {
//
//
//  Purpose:   Add new aggregate into tables and return its index.
//
//  Program Notes:-
//  =============
//
//  aggNo is passed in and not obtained from vrec, so that it can be the gap.

  //  Make sure it really doesn't exist.
  int index = this->IndexOfAggno(aggNo);
  if ( index >=0 ) return index;

  // It doesn't so add it.
  index = fVRecs.size();
  fVRecs.push_back(vrec);
  fAggNoToIndex[aggNo] = index;
  return index;

}

//.....................................................................

UInt_t DbiValidityRecBuilder::AddNewGap(Int_t aggNo) {
//
//
//  Purpose:  Add new aggregate gap into tables and return its index

  UInt_t index = this->AddNewAgg(fGap,aggNo);
  fVRecs[index].SetAggregateNo(aggNo);
  return index;

}
   
//.....................................................................

const DbiValidityRec& 
              DbiValidityRecBuilder::GetValidityRec(Int_t rowNo) const {
//
//
//  Purpose: Return validity record for supplied row number. 

  return (rowNo < 0 || rowNo >= (int) fVRecs.size()) ? fGap : fVRecs[rowNo];
}

//.....................................................................

const DbiValidityRec& 
              DbiValidityRecBuilder::GetValidityRecFromSeqNo(UInt_t SeqNo) const {
//
//
//  Purpose: Return validity record for supplied SeqNo. 

  std::vector<DbiValidityRec>::const_iterator itr = fVRecs.begin();
  std::vector<DbiValidityRec>::const_iterator end = fVRecs.end();
  
  for (; itr != end; ++itr) if ( itr->GetSeqNo() == SeqNo ) return *itr;
  return fGap;
}

//.....................................................................

Int_t DbiValidityRecBuilder::IndexOfAggno(Int_t aggNo) const {
//
//
//  Purpose:   Get index of AggNo or -1 if missing.

  std::map<Int_t,UInt_t>::const_iterator itr = fAggNoToIndex.find(aggNo);
  if ( itr == fAggNoToIndex.end() ) return -1;
  return itr->second;

}

//.....................................................................

void DbiValidityRecBuilder::MakeGapRec(const VldContext& vc, 
                                       const string& tableName,
                                       Bool_t findFullTimeWindow) {
//
//
//  Purpose:  Construct Gap Record
//
//  Arguments: 
//    vc           in    The Validity Context for the query.
//    tableName    in    The name of the table being queried.
//    findFullTimeWindow
//                 in    Attempt to find full validity of query 
//                        i.e. beyond Dbi::GetTimeGate
//
//  Return:        None.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Create the data member gap record fGap centered on the current
//    query time.

//  Program Notes:-
//  =============

//  None.

  Int_t timeGate = Dbi::GetTimeGate(tableName);
  time_t contextSec = vc.GetTimeStamp().GetSec() - timeGate;
  VldTimeStamp startGate(contextSec,0);
  contextSec += 2*timeGate;
  VldTimeStamp endGate(contextSec,0);
  if ( findFullTimeWindow ) {
    startGate = VldTimeStamp(0,0);
    endGate   = VldTimeStamp(0x7FFFFFFF,0);
  }
  VldRange gapVR(vc.GetDetector(), vc.GetSimFlag(), startGate, endGate, "Gap");
  fGap =  DbiValidityRec(gapVR, fTask, -2, 0, 0, kTRUE);

}

---