DbiWriter.tpl

Go to the documentation of this file.

// $id: DbiWriter.tpl,v 1.11 2005/11/11 09:27:26 west Exp $
//
// DbiWriter
//
// Package: Dbi (Database Interface).

#include <cassert>
#include <fstream>

#include "DatabaseInterface/DbiCascader.h"
#include "DatabaseInterface/DbiOutRowStream.h"
#include "DatabaseInterface/DbiResultPtr.h"
#include "DatabaseInterface/DbiSqlValPacket.h"
#include "DatabaseInterface/DbiTableProxy.h"
#include "DatabaseInterface/DbiWriter.h"
#include "LeakChecker/Lea.h"
#include "MessageService/MsgService.h"


ClassImpT(DbiWriter,T)

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

//CVSID("$Id: DbiWriter.tpl,v 1.16 2008/06/03 06:20:01 nwest Exp $");

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

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

template<class T>
DbiWriter<T>::DbiWriter() :
fAggregateNo(-2),
fDbNo(0),
fPacket(new DbiSqlValPacket),
fRequireGlobalSeqno(0),
fTableProxy(&DbiWriter<T>::GetTableProxy()),
fTableName(fTableProxy->GetTableName()),
fUseOverlayCreationDate(kFALSE),
fValidRec(0),
fLogEntry(fTableName)
{
//
//  Purpose:  Default Constructor
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Create Writer.


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

//  Creates an unusable DbiWriter - only present to keep rootcint happy.

  LEA_CTOR    //Leak Checker

  MSG("Dbi", Msg::kVerbose) 
        << "Creating default DbiWriter for " << fTableName << endl;

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

template<class T>
DbiWriter<T>::DbiWriter(const VldRange& vr,
                        Int_t aggNo,
                        Dbi::Task task,
                        VldTimeStamp creationDate,
                        UInt_t dbNo,
                        const std::string& logComment,
                        const std::string& tableName) :
fAggregateNo(aggNo),
fDbNo(dbNo),
fPacket(new DbiSqlValPacket),
fRequireGlobalSeqno(0),
fTableProxy(&DbiWriter<T>::GetTableProxy(tableName)),
fTableName(fTableProxy->GetTableName()),
fUseOverlayCreationDate(creationDate == VldTimeStamp(0,0)),
fValidRec(0),
fLogEntry(fTableName,logComment,vr.GetDetectorMask(),vr.GetSimMask(),task)
{
//
//  Purpose:  Constructor
//
//  Arguments:
//    vr            in       Validity range of validity set.
//    aggNo         in       Aggregate number of validity set.
//    task          in       Task of validity set.
//    creationDate  in       Creation date of validity set.
//    dbNo          in       Database number in cascade (starting at 0).
//    logComment    in       Reason for update.
//    tableName     in       Table name (default: "" - get table name from object type)
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Create Writer.


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

//  None.

  LEA_CTOR    //Leak Checker

  MSG("Dbi", Msg::kVerbose)
        << "Creating DbiWriter for " << fTableName << endl;

  Open(vr,aggNo,task,creationDate,dbNo,logComment);

}

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

template<class T>
DbiWriter<T>::DbiWriter(const VldRange& vr,
                        Int_t aggNo,
                        Dbi::Task task,
                        VldTimeStamp creationDate,
                        const std::string& dbName,
                        const std::string& logComment,
                        const std::string& tableName) :
fAggregateNo(aggNo),
fPacket(new DbiSqlValPacket),
fRequireGlobalSeqno(0),
fTableProxy(&DbiWriter<T>::GetTableProxy(tableName)),
fTableName(fTableProxy->GetTableName()),
fUseOverlayCreationDate(creationDate == VldTimeStamp(0,0)),
fValidRec(0),
fLogEntry(fTableName,logComment,vr.GetDetectorMask(),vr.GetSimMask(),task)
{
//
//  Purpose:  Constructor
//
//  Arguments:
//    vr            in       Validity range of validity set.
//    aggNo         in       Aggregate number of validity set.
//    task          in       Task of validity set.
//    creationDate  in       Creation date of validity set.
//    dbName        in       Database name.
//    logComment    in       Reason for update.
//    tableName     in       Table name (default: "" - get table name from object type)
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Create Writer.


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

//  None.

  LEA_CTOR    //Leak Checker

  MSG("Dbi", Msg::kVerbose)
        << "Creating DbiWriter for " << fTableName << endl;

  Open(vr,aggNo,task,creationDate,dbName,logComment);

}

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

template<class T>
DbiWriter<T>::DbiWriter(const DbiValidityRec& vrec,
                        UInt_t dbNo,
                        const std::string& logComment) :
fAggregateNo(0),
fDbNo(dbNo),
fPacket(new DbiSqlValPacket),
fRequireGlobalSeqno(0),
fTableProxy(0),
fUseOverlayCreationDate(kFALSE),
fValidRec(new DbiValidityRec(vrec)),
fLogEntry(fTableName,logComment,vrec.GetVldRange().GetDetectorMask(),
          vrec.GetVldRange().GetSimMask(),vrec.GetTask())
{
//
//  Purpose:  Constructor
//
//  Arguments: 
//    vrec          in       Validity record for set.
//                           MUST have an associated DbiTableProxy
//    dbNo          in       Database number in cascade (starting at 0).
//    logComment    in       Reason for update.
//
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Create Writer.


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

//  None.

  LEA_CTOR    //Leak Checker

  T pet;
  MSG("Dbi", Msg::kVerbose) 
        << "Creating DbiWriter for " << pet.GetName() << endl;
  
  this->Open(vrec,dbNo,logComment);

}

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

template<class T>
DbiWriter<T>::DbiWriter(const DbiValidityRec& vrec,
                        const std::string& dbName,
                        const std::string& logComment) :
fAggregateNo(0),

fPacket(new DbiSqlValPacket),
fRequireGlobalSeqno(0),
fTableProxy(0),
fUseOverlayCreationDate(kFALSE),
fValidRec(new DbiValidityRec(vrec)),
fLogEntry(fTableName,logComment,vrec.GetVldRange().GetDetectorMask(),
          vrec.GetVldRange().GetSimMask(),vrec.GetTask())
{
//
//  Purpose:  Constructor
//
//  Arguments: 
//    vrec          in       Validity record for set.
//                           MUST have an associated DbiTableProxy
//    dbName        in       Database name.
//    logComment    in       Reason for update.
//
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Create Writer.


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

//  None.

  LEA_CTOR    //Leak Checker

  T pet;
  MSG("Dbi", Msg::kVerbose) 
        << "Creating DbiWriter for " << pet.GetName() << endl;
  
  this->Open(vrec,dbName,logComment);

}

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

template<class T>
DbiWriter<T>::~DbiWriter() {
//
//
//  Purpose: Destructor

  LEA_DTOR    //Leak Checker

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

  Reset();
  delete fPacket;
  fPacket = 0;
  delete fValidRec;
  fValidRec = 0;

}


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

template<class T>
DbiWriter<T>& DbiWriter<T>::operator<<(const T& row) {
//
//
//  Purpose:  Stream row into this DbiWriter.

  if ( ! this->IsOpen() ) return *this;

  Int_t AggNoRow =  row.GetAggregateNo();
  if (  fAggregateNo != AggNoRow ) {
    MSG("Dbi",Msg::kError)
      << "Cannot store row data for table  " 
      << fTableName
      << ", current set has aggregate no.: " << fAggregateNo 
      << ", but it has: " << AggNoRow
      << " \n  closing DbiWriter" << endl;
    this->Abort();
    return *this;
  }
  if ( ! fPacket->AddDataRow(*fTableProxy,fValidRec,row) ) {
    MSG("Dbi",Msg::kError) << "Closing DbiWriter due to above error." << endl;
    this->Abort();
  }
     
  return *this;

}

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

template<class T>
Bool_t DbiWriter<T>::CanOutput(Bool_t reportErrors) const {
//
//
//  Purpose:  Return true if open and ready to receive/output  data. 

  if ( ! this->IsOpen(reportErrors) ) return kFALSE;

  if ( this->NeedsLogEntry() && ! fLogEntry.HasReason() ) {
    if ( reportErrors ) MSG("Dbi",Msg::kError)
      << "Cannot output validity set for table " 
      << fTableName
      << ", writing to Master DB but no log comment has been supplied." << endl;
    return kFALSE;
  }

  UInt_t nstmts = fPacket->GetNumSqlStmts();

  if ( nstmts == 0 ) {
    // not even a VLD insert
    if ( reportErrors ) MSG("Dbi",Msg::kError)
      << "Cannot output validity set for table " 
      << fTableName
      << ", no data has been written." << endl;
    return kFALSE;
  }

  if ( nstmts == 1 ) {
    // if VLD insert present but no data rows, just issue a stern warning
    // as it may be intended to obscure now invalid data
    string stmt = fPacket->GetStmt(0);
    bool isvldentry = 
      (stmt.find("INSERT INTO") != string::npos ) &&
      (stmt.find("VLD VALUES")  != string::npos);
    if ( isvldentry ) {
      if ( reportErrors ) MSG("Dbi",Msg::kWarning)
        << "VLD entry but no data for " 
        << fTableName << endl;
    }
    else {
      // this should never, ever happen ... but let's be paranoid
      if ( reportErrors ) {
        MSG("Dbi",Msg::kError) 
          << "Cannot output validity set for table " 
          << fTableName
          << ", (no VLD info) no data has been written." << endl;
        fPacket->Print();
      }
      return kFALSE;
    }
  }

  return kTRUE;
}


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

template<class T>
Bool_t DbiWriter<T>::Close(const char* fileSpec) {
//
//
//  Purpose:  Close current validity set and write it to the database.
//
//  Arguments:
//
//  fileSpec       in   File pointer.  If not null write to file instead of database.
//
//  Return:    kTRUE is I/O successful.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Close current validity set and write it to the database.

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

//  None.

  Bool_t ok = kFALSE;
  
// Skip output unless good data to output.

  if ( CanOutput() ) {

//  Find the next free sequence number.  It must be global if writing to a
//  to a file, otherwise it can be local if DB isn't authorising.
    int seqNoType = fileSpec ? 1 : fRequireGlobalSeqno;
    Int_t seqNo = fTableProxy->GetCascader().AllocateSeqNo(fTableName,seqNoType,fDbNo);
    if ( seqNo <= 0 ) {
      MSG("Dbi",Msg::kError)
        << "Cannot get sequence number for table " 
        << fTableName << endl;
    }
    
    else {

//  Use overlay creation date if required.
      if ( fUseOverlayCreationDate &&  fValidRec 
          ) fPacket->SetCreationDate(fTableProxy->QueryOverlayCreationDate(*fValidRec,fDbNo));

//  Set SEQNO and perform I/O.
      fPacket->SetSeqNo(seqNo);
      if ( fileSpec ) {
        ofstream fs(fileSpec,ios_base::app);
        if ( ! fs ) MSG("Dbm", Msg::kError) << "Unable to open " << fileSpec << endl;
        else        ok = fPacket->Write(fs,true);
      }
      else {
        ok = fPacket->Store(fDbNo);
      }

//  Record update if I/O successful and required.
      if ( ok && this->WritingToMaster() ) {
       if ( this->NeedsLogEntry() || fLogEntry.HasReason() )
        ok = fLogEntry.Write(fDbNo,seqNo);
      }
    }
  } 
  
//  Clear out ready for any further I/O.

  fPacket->Clear();

  return ok;
}
//.....................................................................

template<class T>
void DbiWriter<T>::CompleteOpen(UInt_t dbNo,
                                const std::string& logComment) {
//
//
//  Purpose:  Complete the open process
//
//  Arguments: 
//    dbNo          in       Database number in cascade (starting at 0).
//    logComment    in       Reason for update.
//
//
//  Specification:-
//  =============
//
//  o Complete reinitialisation for new I/O 

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

//  Assumes that fTableProxy, fUseOverlayCreationDate, fValidRec are 
//  already initialised.


  fDbNo = dbNo;
  if ( (int) fDbNo < 0 ) {
    MSG("Dbi",Msg::kError) << "Bad database name/number selected. " << endl;
    this->Reset();
    return;
  }

  fAggregateNo = fValidRec->GetAggregateNo();
  fTableName   = fTableProxy->GetTableName(),

// Recreate validity packet.
  fPacket->Recreate(fTableName,
                    fValidRec->GetVldRange(),
                    fAggregateNo,
                    fValidRec->GetTask(),
                    fValidRec->GetCreationDate());

// Recreate log entry.
  const VldRange&  vr = fValidRec->GetVldRange();
  fLogEntry.Recreate(fTableName,
                     logComment,
                     vr.GetDetectorMask(),
                     vr.GetSimMask(),
                     fValidRec->GetTask());

}

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

template<class T>
DbiTableProxy& DbiWriter<T>::GetTableProxy() {
//
//
//  Purpose:  Private static function to find default associated 
//            DbiTableProxy.

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

//  As DbiResultPtr classes are in 1:1 correspondance with DbiWriter
//  classes, DbiWriter uses the static methods from DbiResultPtr
//  to find the associated DbiTableProxy.

  return DbiResultPtr<T>::GetTableProxy();
}

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

template<class T>
DbiTableProxy& DbiWriter<T>::GetTableProxy(
                                           const std::string& tableName){
//
//
//  Purpose:  Private static function to find an alternative 
//            associated DbiTableProxy.
//
//  Arguments: 
//    tableName    in    Alternative table name
//
//  Return:   Associated DbiTableProxy. 
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Ask Registry for alternative  Table Proxy and return it.

//  As DbiResultPtr classes are in 1:1 correspondance with DbiWriter
//  classes, DbiWriter uses the static methods from DbiResultPtr
//  to find the associated DbiTableProxy.

  return DbiResultPtr<T>::GetTableProxy(tableName);

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

template<class T>
Bool_t DbiWriter<T>::IsOpen(Bool_t reportErrors) const {
//
//
//  Purpose:  Return true if open and ready to receive data.

  if ( ! DbiTableProxyRegistry::IsActive()  ) {
    if ( reportErrors ) MSG("Dbi",Msg::kError)
      << "Cannot use DbiWriter, the DBI has been shutdown." << endl;
  }
  else if (    !fValidRec
            ||  fPacket->GetNumSqlStmts() < 1 ) {
    if ( reportErrors ) MSG("Dbi",Msg::kError)
      << "Cannot do I/O on DbiWriter for " 
      << fTableName
      <<", it is currently closed." << endl;
  }
  else return kTRUE;

  return kFALSE;

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

template<class T>
Bool_t DbiWriter<T>::NeedsLogEntry() const {
//
//
//  Purpose:  Return true if a log entry is required.

  // Some tables are created automatically so don't require entries.
  string tableName(fTableName);
  if (    tableName.substr(0,7)  == "BEAMMON"
       || tableName.substr(0,16) == "BFLDDBICOILSTATE"
       || tableName.substr(0,3)  == "CAL"
       || tableName.substr(0,20) == "CANDDIGITBADCHANNELS"
       || tableName.substr(0,3)  == "DBU"
       || tableName.substr(0,3)  == "DCS"
       || tableName.substr(0,6)  == "PULSER"
       || tableName.substr(0,9)  == "SPILLTIME" ) return kFALSE;

  // All other tables need entries if writing to a Master database.

  return this->WritingToMaster();

}

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

template<class T>
Bool_t DbiWriter<T>::Open (const VldRange& vr,
                           Int_t aggNo,
                           Dbi::Task task,
                           VldTimeStamp creationDate,
                           UInt_t dbNo,
                           const std::string& logComment) {
//
//
//  Purpose:  Output any existing data and open new validity set.
//
//  Arguments: 
//    vr            in       Validity range of validity set.
//    aggNo         in       Aggregate number of validity set.
//    task          in       Task of validity set.
//    creationDate  in       Creation date of validity set.
//    dbNo          in       Database number in cascade (starting at 0).
//    logComment    in       Reason for update.
//
//  Return:    kTRUE if no errors detected.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Output any existing data and open new validity set.

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

//  None.

  bool ok = true;

  if ( ! DbiTableProxyRegistry::IsActive() ) return kFALSE;
  if ( this->CanOutput(kFALSE) ) ok = Close();

// Test for special creation date.
  fUseOverlayCreationDate = creationDate == VldTimeStamp(0,0);

//  Create a validity record.
  delete fValidRec;
  fValidRec = new DbiValidityRec(vr,task,aggNo,0,0,kFALSE,creationDate);

// Get a proxy.
  fTableProxy = &DbiWriter<T>::GetTableProxy(fTableName); 

// Complete opening.
  this->CompleteOpen(dbNo,logComment);
  return ok;

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

template<class T>
Bool_t DbiWriter<T>::Open (const VldRange& vr,
                           Int_t aggNo,
                           Dbi::Task task,
                           VldTimeStamp creationDate,
                           const string& dbName,
                           const std::string& logComment) {
//
//
//  Purpose:  Output any existing data and open new validity set.
//
//  Arguments: 
//    vr            in       Validity range of validity set.
//    aggNo         in       Aggregate number of validity set.
//    task          in       Task of validity set.
//    creationDate  in       Creation date of validity set.
//    dbName        in       Database name.
//    logComment    in       Reason for update.
//
//  Return:    kTRUE if no errors detected.

  this->SetDbName(dbName);
  return this->Open(vr,
                    aggNo,
                    task,
                    creationDate,
                    fDbNo,
                    logComment);

}

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

template<class T>
Bool_t DbiWriter<T>::Open(const DbiValidityRec& vrec,
                          UInt_t dbNo,
                          const std::string& logComment) {

//
//  Purpose:  Output any existing data and open new validity set.
//
//  Arguments: 
//    vrec          in       Validity record for set.
//                           MUST have an associated DbiTableProxy
//    dbNo          in       Database number in cascade (starting at 0).
//    logComment    in       Reason for update.
//
//
//  Return:    kTRUE if no errors detected.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Output any existing data and open new validity set.


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

//  None.

  bool ok = true;

  if ( ! DbiTableProxyRegistry::IsActive() ) return kFALSE;
  if ( this->CanOutput(kFALSE) ) ok = Close();

  
// Check that vrec is associated with the right table, but waive
// test for DbiConfigSet so that it can be used with any.
  const DbiTableProxy& proxyDefault = DbiWriter<T>::GetTableProxy();
  const DbiTableProxy& proxyVrec    = *vrec.GetTableProxy();
  if (    proxyDefault.GetTableName() != "DBICONFIGSET"
       &&    proxyVrec.GetTableName() != proxyDefault.GetTableName() ) {
    MSG("Dbi",Msg::kError) 
       << "Unable to create DbiWriter from query:" << endl
       << vrec
       << " was filled by " << proxyVrec.GetTableName() 
       << " not by " << proxyDefault.GetTableName() << endl;
    this->Reset();
    return false;
  }
  else { 
//  Have to cast away const - DbiWriter needs a modifiable DbiTableProxy.
    fTableProxy = const_cast<DbiTableProxy*>(&proxyVrec);
  }

  fUseOverlayCreationDate = vrec.GetCreationDate() == VldTimeStamp(0,0);

  delete fValidRec;
  fValidRec = new DbiValidityRec(vrec);

// Complete opening.
  this->CompleteOpen(dbNo,logComment);
  return ok;

}

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

template<class T>
Bool_t DbiWriter<T>::Open(const DbiValidityRec& vrec,
                          const string& dbName,
                          const std::string& logComment) {

//
//  Purpose:  Output any existing data and open new validity set.
//
//  Arguments: 
//    vrec          in       Validity record for set.
//                           MUST have an associated DbiTableProxy
//    dbName        in       Database name.
//    logComment    in       Reason for update.
//
//
//  Return:    kTRUE if no errors detected.

  this->SetDbName(dbName);
  return this->Open(vrec,
                    fDbNo,
                    logComment);

}

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

template<class T>
void DbiWriter<T>::Reset() {
//
//
//  Purpose:  Clear out data and reset ready for any further I/O.
//
//  Arguments: None.
//
//  Return:    None.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Clear out data and reset ready for any further I/O.

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

//  None.

  fAggregateNo = 0;
  fDbNo        = 0;
  fPacket->Clear();
  fTableProxy  = &DbiWriter<T>::GetTableProxy();
  fTableName   = fTableProxy->GetTableName();

  delete fValidRec;
  fValidRec    = 0;

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

template<class T>
void DbiWriter<T>::SetDbName(const string& dbName) {
//
//
//  Purpose:  Set Database entry by name.  Default: entry 0.

  if ( dbName == "" ) {
    fDbNo = 0;
  }
  else {
    fDbNo =  DbiTableProxyRegistry::Instance().GetCascader().GetDbNo(dbName);
  }
}

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

template<class T>
void DbiWriter<T>::SetLogComment(const std::string& reason) {
//
//
//  Purpose:  Set log comment.

  fLogEntry.SetReason(reason);

}

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

template<class T>
DbiTableProxy& DbiWriter<T>::TableProxy() const  {
//
//
//  Purpose:  Return DbiTableProxy.
//

  assert( DbiTableProxyRegistry::IsActive() );
  return *fTableProxy;
}

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

template<class T>
Bool_t DbiWriter<T>::WritingToMaster() const {
//
//
//  Purpose:  Return true if writing permanent data to a Master Database.


  DbiCascader& cascader = DbiTableProxyRegistry::Instance().GetCascader();
  return  (    fDbNo == (UInt_t) cascader.GetAuthorisingDbNo()
            && ! cascader.IsTemporaryTable(fTableName,fDbNo));

}

/*    Template for New Member Function

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

template<class T>
DbiWriter<T>:: {
//
//
//  Purpose:  
//
//  Arguments: 
//    xxxxxxxxx    in    yyyyyy
//
//  Return:    
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o 

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

//  None.


}

*/

---