Coverage.cxx

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/calibUtil/src/dbIntegrity/Coverage.cxx,v 1.1.1.1
// 2005/10/17 06:12:26 maqm Exp $
/**
   @file Coverage.cxx
 
   Implementation of Coverage class
 
   Also define and implement tiny data-only helper class
*/
#include "Coverage.h"
#include "calibUtil/Metadata.h"
#include "facilities/Util.h"
#include "rdbModel/Management/Manager.h"
#include "rdbModel/Management/XercesBuilder.h"
#include <cstdio>
#include <iostream>
 
#include "rdbModel/Db/MysqlConnection.h"
#include "rdbModel/Db/MysqlResults.h"
#include "rdbModel/Rdb.h"
#include "rdbModel/RdbException.h"
#include "rdbModel/Tables/Assertion.h"
#include "rdbModel/Tables/Column.h"
#include "rdbModel/Tables/Table.h"
 
class SelectInfo {
public:
  SelectInfo( int ser, const facilities::Timestamp& start, const facilities::Timestamp& end )
      : m_ser( ser ) {
    using facilities::Timestamp;
    m_vstart = Timestamp( start.getClibTime() );
    m_vend   = Timestamp( end.getClibTime() );
  }
  int                   m_ser;
  facilities::Timestamp m_vstart;
  facilities::Timestamp m_vend;
};
 
std::ostream& operator<<( std::ostream& out, const SelectInfo& info ) {
  out << "Serial #" << info.m_ser << " validitiy interval [" << info.m_vstart.getString()
      << ", " << info.m_vend.getString() << "]" << std::endl;
  return out;
}
 
Coverage::Coverage( calibUtil::Metadata* meta, const std::string& instr,
                    const std::string& flavor, const std::string& level,
                    const facilities::Timestamp& ts )
    : m_instr( instr ), m_flavor( flavor ), m_level( level ), m_overlap( 300 ) {
  m_ts = facilities::Timestamp( ts.getClibTime() );
  m_selects.reserve( 3 );
  m_selects.push_back( "ser_no" );
  m_selects.push_back( "vstart" );
  m_selects.push_back( "vend" );
 
  m_orderBy.reserve( 1 );
  m_orderBy.push_back( "vstart asc" );
 
  m_rdb   = meta->getRdb();
  m_conn  = meta->getReadConnection();
  m_table = meta->getTable();
}
 
// Implement wildcards later
bool Coverage::expandTypes( std::string& nickname, std::vector<std::string>& types ) {
  if ( ( nickname == "CAL" ) || ( nickname == "TKR" ) || ( nickname == "*" ) )
  {
    if ( !m_rdb )
    {
      std::cerr << "Unable to expand wildcard argument " << nickname
                << " without schema for metadata dbs " << std::endl;
    }
    else
    {
      std::cerr << "Wildcard expansion of calib_type argument not yet supported";
      std::cerr << std::endl << "Have a nice day" << std::endl;
    }
    std::cerr.flush();
    exit( 1 );
  }
  types.push_back( nickname );
  return true;
}
 
unsigned Coverage::checkType( std::string calibtype ) {
  using namespace rdbModel;
  using facilities::Timestamp;
  // Make a query to find all rows matching criteria, ordered ascending
  // by vstart
  //    match calib_type, flavor, instrument, proc_level
  //    completion = "OK"
  //    vstart >= ts
  // Ask for return of ser_no, vstart, vend
 
  std::vector<Assertion::Operator*> conditions;
  conditions.reserve( 6 );
 
  Assertion::Operator completeOp( OPTYPEequal, "completion", "OK", FIELDTYPEold,
                                  FIELDTYPElit );
  //                                  false, true);
  Assertion::Operator instOp( OPTYPEequal, "instrument", m_instr, FIELDTYPEold, FIELDTYPElit );
  // false, true);
  Assertion::Operator calibTypeOp( OPTYPEequal, "calib_type", calibtype, FIELDTYPEold,
                                   FIELDTYPElit );
  //                  false, true);
  Assertion::Operator flavorOp( OPTYPEequal, "flavor", m_flavor, FIELDTYPEold, FIELDTYPElit );
  //    false, true);
  Assertion::Operator levelOp( OPTYPEequal, "proc_level", m_level, FIELDTYPEold,
                               FIELDTYPElit );
  //                        false, true);
  Assertion::Operator vstartOp( OPTYPElessThan, m_ts.getString(), "vstart", FIELDTYPElit,
                                FIELDTYPEold );
  //  true, false);
  conditions.push_back( &calibTypeOp );
  conditions.push_back( &instOp );
  conditions.push_back( &flavorOp );
  conditions.push_back( &levelOp );
  conditions.push_back( &vstartOp );
  conditions.push_back( &completeOp );
  Assertion::Operator* andOp       = new Assertion::Operator( OPTYPEand, conditions );
  Assertion*           whereClause = new Assertion( andOp );
 
  ResultHandle* results = 0;
 
  try
  { // make the query
    results = m_conn->select( m_table, m_selects, m_orderBy, whereClause );
  } catch ( RdbException ex )
  {
    std::cerr << ex.getMsg() << std::endl;
    std::cerr.flush(); // exit(1);
    return false;
  }
 
  if ( !results )
  { // Error. Should have ResultHandle even if 0 rows.
    std::cerr << "Error making query " << std::endl;
    std::cerr.flush();
    exit( 1 );
  }
 
  // Save returned values
  std::vector<SelectInfo> info;
  unsigned                nFound = results->getNRows();
 
  if ( !nFound )
  {
    std::cout << "No calibrations found for calib_type '" << calibtype << "'" << std::endl;
    return true;
  }
 
  info.reserve( results->getNRows() );
 
  unsigned                 iRow = 0;
  std::vector<std::string> fields;
  fields.reserve( 3 );
 
  bool     ok      = true;
  unsigned retCode = 0;
 
  // 1. For each row store columnes; check if vstart <  vend
  std::cout << std::endl << "Checking for valid timestamps, vstart < vend .. " << std::endl;
  for ( iRow = 0; iRow < nFound; iRow++ )
  {
    results->getRow( fields, iRow );
    int ser = facilities::Util::stringToInt( fields[0] );
    try
    {
      Timestamp vstart = Timestamp( fields[1] );
      Timestamp vend   = Timestamp( fields[2] );
      info.push_back( SelectInfo( ser, vstart, vend ) );
 
      if ( vend.getClibTime() < vstart.getClibTime() )
      {
        std::cerr << "vend < vstart for " << info.back();
        ok      = false; // or could discard the row and try to continue
        retCode = 1;
      }
    } catch ( facilities::BadTimeInput ex )
    {
      std::cerr << "Bad vstart or vend in row " << ser << std::endl;
      ok      = false;
      retCode = 1;
    }
  }
  if ( !ok ) return retCode;
 
  // 2. Check if vend's also increase monotonically
  std::cout << std::endl << "Checking for vends monotonic.. " << std::endl;
  for ( iRow = 0; iRow < nFound - 1; iRow++ )
  {
    if ( info[iRow].m_vend.getClibTime() > info[iRow + 1].m_vend.getClibTime() )
    {
      std::cerr << "Validity interval for row with serial #" << info[iRow + 1].m_ser
                << " completely contained in interval for row with serial #"
                << info[iRow].m_ser << std::endl;
      std::cerr << info[iRow];
      std::cerr << info[iRow + 1] << std::endl;
      ok      = false;
      retCode = 2;
    }
  }
  if ( !ok ) return retCode;
 
  // 3. Look for gaps
  std::cout << std::endl << "Checking for gaps.. " << std::endl;
  for ( iRow = 0; iRow < nFound - 1; iRow++ )
  {
    if ( info[iRow].m_vend < info[iRow + 1].m_vstart )
    {
      std::cerr << "Validity interval gap between calibrations with serial #"
                << info[iRow].m_ser << " and #" << info[iRow + 1].m_ser << std::endl;
      std::cerr << info[iRow];
      std::cerr << info[iRow + 1] << std::endl;
      ok      = false;
      retCode = 3;
    }
  }
  // 4. Look for overlaps
  std::cout << std::endl << "Checking for overlaps.. " << std::endl;
  for ( iRow = 0; iRow < nFound - 1; iRow++ )
  {
    if ( ( info[iRow].m_vend ).getClibTime() >
         ( info[iRow + 1].m_vstart ).getClibTime() + m_overlap )
    {
      std::cerr << "Unacceptable overlap between serial #" << info[iRow].m_ser << " and #"
                << info[iRow + 1].m_ser << std::endl;
      std::cerr << info[iRow];
      std::cerr << info[iRow + 1] << std::endl;
      ok = false;
      if ( !retCode ) retCode = 4;
    }
  }
  return retCode;
}