test_build.cxx

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/rdbModel/src/test/test_build.cxx,v 1.1.1.1 2005/10/17
// 06:10:53 maqm Exp $ Test program for rdbModel primitive buiding blocks
 
#include "facilities/Util.h"
#include "rdbModel/Db/MysqlConnection.h"
#include "rdbModel/Db/MysqlResults.h"
#include "rdbModel/Management/Manager.h"
#include "rdbModel/Management/XercesBuilder.h"
#include "rdbModel/Rdb.h"
#include "rdbModel/RdbException.h"
#include "rdbModel/Tables/Assertion.h"
#include "rdbModel/Tables/Column.h"
#include "rdbModel/Tables/Datatype.h"
#include "rdbModel/Tables/Table.h"
#include <cstdlib>
#include <iostream>
#include <string>
 
#define TEST_INSERT
 
int  doInsert( rdbModel::Rdb* con );
int  doSmartInsert( rdbModel::Rdb* rdb );
int  doUpdate( rdbModel::Rdb*, int serial );
void tryQuick( rdbModel::Table* t, const std::string& colname );
int  doSupersedes( rdbModel::Rdb* rdb, int serial, int* newSerial );
int  doSupersede( rdbModel::Rdb* rdb, rdbModel::Row& row, int serial, int* newSerial );
int  main( int, char** ) {
  using rdbModel::FieldVal;
 
  std::string infile( "$(RDBMODELROOT)/xml/calib_test.xml" );
 
  rdbModel::Manager* man = rdbModel::Manager::getManager();
 
  man->setBuilder( new rdbModel::XercesBuilder );
  man->setInputSource( infile );
 
  // good errcode is 0
  int errcode = man->build();
 
  if ( errcode )
  {
    std::cerr << "Build failed with error code " << errcode << std::endl;
    return errcode;
  }
  rdbModel::Rdb* rdb = man->getRdb();
 
  rdbModel::Table* t = rdb->getTable( "metadata_v2r1" );
 
  tryQuick( t, "ser_no" );
  tryQuick( t, "calib_type" );
  tryQuick( t, "notes" );
  tryQuick( t, "prod_start" );
  tryQuick( t, "vstart" );
 
  rdbModel::Assertion*  a = t->getAssertionByName( "maySupersede" );
  std::vector<FieldVal> oldFields;
  oldFields.reserve( 10 );
  oldFields.push_back( FieldVal( "proc_level", "PROD", false ) );
  oldFields.push_back( FieldVal( "calib_type", "CAL_Ped", false ) );
  oldFields.push_back( FieldVal( "ser_no", "17", false ) );
  oldFields.push_back( FieldVal( "completion", "OK", false ) );
  oldFields.push_back( FieldVal( "prod_start", "", true ) );
 
  rdbModel::Row oldRow1( oldFields );
  rdbModel::Row toBeRow;
 
  bool checkOld = a->verify( oldRow1, toBeRow );
 
  std::cout << "Result of verifying 'maySupersede' against oldRow1: " << checkOld << std::endl
            << std::endl;
 
  oldFields.clear();
  oldFields.push_back( FieldVal( "proc_level", "DEV", false ) );
  oldFields.push_back( FieldVal( "calib_type", "CAL_Ped", false ) );
  oldFields.push_back( FieldVal( "ser_no", "17", false ) );
  oldFields.push_back( FieldVal( "completion", "OK", false ) );
 
  rdbModel::Row oldRow2( oldFields );
 
  checkOld = a->verify( oldRow2, toBeRow );
 
  std::cout << "Result of verifying 'maySupersede' against oldRow2: " << checkOld << std::endl
            << std::endl;
 
  std::string colMin;
  std::string colMax;
 
  rdbModel::Column* serCol = rdb->getColumn( "metadata_v2r1", "ser_no" );
  if ( serCol )
  {
    rdbModel::Datatype* serType = serCol->getDatatype();
 
    std::cout << "Value of isPrimaryKey() for column ser_no is: " << serCol->isPrimaryKey()
              << std::endl;
 
    if ( serType->getInterval( colMin, colMax ) )
    { std::cout << "Min and max for ser_no are " << colMin << ", " << colMax << std::endl; }
    else { std::cout << "ser_no has no min, max " << std::endl; }
  }
  else std::cout << "no such column as 'ser_no' " << std::endl;
 
  rdbModel::Column* vstartCol = rdb->getColumn( "metadata_v2r1", "vstart" );
  if ( vstartCol )
  {
    rdbModel::Datatype* vstartType = vstartCol->getDatatype();
 
    if ( vstartType->getInterval( colMin, colMax ) )
    { std::cout << "Min and max for vstart are " << colMin << ", " << colMax << std::endl; }
    else { std::cout << "vstart has no min, max " << std::endl; }
  }
  else std::cout << "no such column as 'vstart' " << std::endl;
 
    // mostly don't want to run code doing an insert.  For times
    // when we do, must connect as user with INSERT priv.
#ifdef TEST_INSERT
  std::string connectfileT( "$(RDBMODELROOT)/xml/connect/mysqlTester.xml" );
#else
  std::string connectfileT( "$(RDBMODELROOT)/xml/connect/mysqlSlacT.xml" );
#endif
 
  // Connect to production database, read only
  rdbModel::MysqlConnection* con = new rdbModel::MysqlConnection();
 
  std::string connectfile( "$(RDBMODELROOT)/xml/connect/mysqlSlac.xml" );
 
  if ( !( con->open( connectfile ) ) )
  {
    std::cerr << "Unable to connect to MySQL database" << std::endl;
    return -1;
  }
 
  rdbModel::MATCH match = con->matchSchema( rdb, false );
 
  switch ( match )
  {
  case rdbModel::MATCHequivalent:
    std::cout << "XML schema and MySQL database are equivalent!" << std::endl;
    break;
  case rdbModel::MATCHcompatible:
    std::cout << "XML schema and MySQL database are compatible" << std::endl;
    break;
  case rdbModel::MATCHfail:
    std::cout << "XML schema and MySQL database are NOT compatible" << std::endl;
    return -2;
  case rdbModel::MATCHnoConnection:
    std::cout << "Connection failed while attempting match" << std::endl;
    return -1;
  }
 
  // Make a query
  std::string rq[3];
  rq[0] = "select * from metadata_v2r1";
  rq[1] = "select calib_type from metadata_v2r1";
  rq[2] = "select garbage from metadata_v2r1";
  for ( int i = 0; i < 3; i++ )
  {
    try
    {
      rdbModel::ResultHandle* res = con->dbRequest( rq[i] );
      if ( res )
      {
        std::cout << "dbRequest '" << rq[i] << "'" << std::endl;
        std::cout << "succeeded, returned " << res->getNRows() << " rows" << std::endl;
      }
      else
      {
        std::cout << "dbRequest '" << rq[i] << "'" << std::endl;
        std::cout << "succeeded, no returned data expected" << std::endl;
      }
    } catch ( rdbModel::RdbException ex )
    {
      std::cerr << "dbRequest '" << rq[i] << "'" << std::endl;
      std::cerr << " failed with error: " << ex.getMsg() << std::endl;
      std::cerr << "Code " << ex.getCode() << std::endl;
    }
  }
 
  // Now try to close connection, then reopen.
  con->close();
 
  if ( !( con->open( connectfile ) ) )
  {
    std::cerr << "Unable to connect to MySQL database" << std::endl;
    return -1;
  }
  con->close();
 
  // Now open with alternate connection file
  if ( !( con->open( connectfileT ) ) )
  {
    std::cerr << "Unable to connect to MySQL database" << std::endl;
    return -1;
  }
  match = con->matchSchema( rdb );
 
  // Following will do an insert.  To keep from cluttering up the
  // database, mostly don't execute
  //
#ifdef TEST_INSERT
  bool disable = true;
  con->disableModify( disable ); // so don't really change db
  int serial = doInsert( rdb );
  if ( serial )
  {
    std::cout << "Hallelujah!  Inserted new row, serial# " << serial << std::endl;
    // Try to supersede.  Should fail since flavor != "vanilla"
    /*
    int newSerial;
    bool didSup = doSupersedes(rdb, serial, &newSerial);
    if (didSup) {
      std::cout << "Supersede of " << serial << " successful." << std::endl;
      std::cout << "New row is " << newSerial << std::endl;
    }
    else {
      std::cout << "Supersede of " << serial << " failed" << std::endl;
    }
    */
  }
  else if ( disable )
  { // pick random serial# to check out disabled update
    serial = 17;
  }
  if ( serial )
  {
    // Now try update
    /*    int nUpdates = doUpdate(con, serial);  */
    int nUpdates = doUpdate( rdb, serial );
 
    if ( nUpdates ) { std::cout << "Did " << nUpdates << " on row " << serial << std::endl; }
    else std::cout << "Failed to update row " << serial << std::endl;
  }
  else { std::cout << "Bah, humbug.  Insert failed. " << std::endl; }
 
  serial = doSmartInsert( rdb );
  if ( serial )
  {
    std::cout << "Did insertLatest, inserted new row with ser_no = " << serial << std::endl;
    // Try to supersede.  Should fail since flavor != "vanilla"
    int  newSerial;
    bool didSup = doSupersedes( rdb, serial, &newSerial );
    if ( didSup )
    {
      std::cout << "Supersede of " << serial << " successful." << std::endl;
      std::cout << "New row is " << newSerial << std::endl;
    }
    else { std::cout << "Supersede of " << serial << " failed" << std::endl; }
  }
  else if ( !disable ) { std::cout << "Bah, humbug.  insertLatest failed. " << std::endl; }
#else
 
  // Check that we can really do something with this connection
 
  switch ( match )
  {
  case rdbModel::MATCHequivalent:
    std::cout << "XML schema and MySQL database are equivalent!" << std::endl;
    break;
  case rdbModel::MATCHcompatible:
    std::cout << "XML schema and MySQL database are compatible" << std::endl;
    break;
  case rdbModel::MATCHfail:
    std::cout << "XML schema and MySQL database are NOT compatible" << std::endl;
    break;
    //    return -2;
  case rdbModel::MATCHnoConnection:
    std::cout << "Connection failed while attempting match" << std::endl;
    return -1;
  }
 
  if ( match == rdbModel::MATCHfail )
  { // try again without dbname match
    match = con->matchSchema( rdb, false );
 
    switch ( match )
    {
    case rdbModel::MATCHequivalent:
      std::cout << "XML schema and MySQL database are equivalent!" << std::endl;
      break;
    case rdbModel::MATCHcompatible:
      std::cout << "XML schema and MySQL database are compatible" << std::endl;
      break;
    case rdbModel::MATCHfail:
      std::cout << "XML schema and MySQL database are NOT compatible" << std::endl;
      //    return -2;
    case rdbModel::MATCHnoConnection:
      std::cout << "Connection failed while attempting match" << std::endl;
      return -1;
    }
  }
#endif
 
  return 0;
}
 
// int doInsert(rdbModel::Connection* con) {
int doInsert( rdbModel::Rdb* rdb ) {
 
  using rdbModel::FieldVal;
  using rdbModel::Row;
 
  std::vector<FieldVal> fields;
  fields.reserve( 15 );
 
  fields.push_back( FieldVal( "instrument", "LAT" ) );
  fields.push_back( FieldVal( "calib_type", "Test_Gen" ) );
  fields.push_back( FieldVal( "flavor", "berry" ) );
  fields.push_back( FieldVal( "data_fmt", "nonsense" ) );
  fields.push_back( FieldVal( "vstart", "2003-02-01" ) );
  fields.push_back( FieldVal( "data_size", "0" ) );
  fields.push_back( FieldVal( "locale", "phobos" ) );
  fields.push_back( FieldVal( "completion", "ABORT" ) );
  fields.push_back( FieldVal( "data_ident", "$(mycalibs)/test/moreJunk.xml" ) );
  fields.push_back( FieldVal( "notes", "Absurd test item, setting input_desc to NULL" ) );
  fields.push_back( FieldVal( "input_desc", "", true ) );
 
  int serial = 0;
 
  Row row( fields );
 
  rdb->insertRow( "metadata_v2r1", row, &serial );
 
  return serial;
}
/*            start here */
int doSmartInsert( rdbModel::Rdb* rdb ) {
  using rdbModel::FieldVal;
 
  std::vector<FieldVal> fields;
  fields.reserve( 15 );
 
  fields.push_back( FieldVal( "instrument", "LAT" ) );
  fields.push_back( FieldVal( "calib_type", "CAL_Ped" ) );
  fields.push_back( FieldVal( "flavor", "vanilla" ) );
  fields.push_back( FieldVal( "proc_level", "PROD" ) );
  fields.push_back( FieldVal( "completion", "OK" ) );
  fields.push_back( FieldVal( "data_fmt", "XML" ) );
  fields.push_back( FieldVal( "fmt_version", "1.1" ) );
  fields.push_back( FieldVal( "data_ident", "nofile.xml" ) );
  fields.push_back( FieldVal( "vstart", "2004-01-04" ) );
  fields.push_back( FieldVal( "vend", "2030-01-01" ) );
  fields.push_back( FieldVal( "locale", "Oz" ) );
  fields.push_back( FieldVal( "input_desc", "none" ) );
  fields.push_back( FieldVal( "notes", "trying out insertLatest" ) );
  fields.push_back( FieldVal( "prod_end", "", true ) );
  fields.push_back( FieldVal( "input_start", "", true ) );
  fields.push_back( FieldVal( "input_end", "", true ) );
 
  rdbModel::Row row( fields );
 
  int serial = 0;
  try
  { rdb->insertLatest( "metadata_v2r1", row, &serial ); } catch ( rdbModel::RdbException ex )
  { std::cerr << "insertLatest failed with message" << ex.getMsg(); }
  return serial;
}
 
// int doUpdate(rdbModel::Connection* con, int serial) {
int doUpdate( rdbModel::Rdb* rdb, int serial ) {
  using facilities::Util;
  using rdbModel::Assertion;
  using rdbModel::Column;
  using rdbModel::FieldVal;
  using rdbModel::Row;
 
  // Set up WHERE clause, always the same
  std::string serialStr;
  Util::itoa( serial, serialStr );
  Assertion::Operator* serEquals =
      new Assertion::Operator( rdbModel::OPTYPEequal, "ser_no", serialStr,
                               rdbModel::FIELDTYPEold, rdbModel::FIELDTYPElit );
 
  Assertion* whereSer = new Assertion( serEquals );
  //  Assertion* whereSer = new Assertion(Assertion::WHENwhere, serEquals);
 
  // First call an update without any null columns; change notes field
  // and set data_size to something.
  /*  std::vector<std::string> colNames, values, nullCols; */
  std::vector<FieldVal> fields;
 
  fields.push_back( FieldVal( "notes", "1st update: set data_size to non-zero value" ) );
  fields.push_back( FieldVal( "data_size", "883" ) );
 
  Row row( fields );
 
  std::string table( "metadata_v2r1" );
 
  unsigned nChange = rdb->updateRows( table, row, whereSer );
 
  // Now null out data_size
  fields.clear();
  fields.push_back( FieldVal( "data_size", "", true ) );
  fields.push_back( FieldVal( "notes", "2nd update: data_size set to NULL" ) );
  Row row2( fields );
 
  nChange += rdb->updateRows( table, row2, whereSer );
  return nChange;
}
 
void tryQuick( rdbModel::Table* t, const std::string& colname ) {
  //  rdbModel::Column* cQuick = t->getQuick(colname);
  rdbModel::Column* col = t->getColumnByName( colname );
 
  if ( !col )
  {
    std::cerr << colname << " not found by getQuick" << std::endl;
    return;
  }
 
  std::string name = col->getName();
  if ( colname.compare( name ) != 0 )
  { std::cerr << "Instead of " << colname << ", getColumnByName found " << name << std::endl; }
 
  else
  { std::cout << "getColumnByName found correct column with name " << colname << std::endl; }
}
 
int doSupersedes( rdbModel::Rdb* rdb, int serial, int* newSerial ) {
  using rdbModel::FieldVal;
  using rdbModel::Row;
 
  int retVal;
  int nSuccess = 0;
  Row row;
 
  // First put something in row that doesn't belong there
  row.addField( FieldVal( "data_ident", "supFile.xml" ) );
  row.addField( FieldVal( "notes", "this supersede is not supposed to work" ) );
  row.addField( FieldVal( "instrument", "cello" ) );
 
  retVal = doSupersede( rdb, row, serial, newSerial );
  if ( !retVal ) nSuccess++;
 
  // Now leave out something necessary
  row.clear();
  row.addField( FieldVal( "notes", "oops!  left out data_ident" ) );
 
  retVal = doSupersede( rdb, row, serial, newSerial );
  if ( !retVal ) nSuccess++;
 
  // Now try to do it right!
  row.clear();
  row.addField( FieldVal( "data_ident", "supFile.xml" ) );
  row.addField( FieldVal( "notes", "Try supersede with good row input" ) );
  retVal = doSupersede( rdb, row, serial, newSerial );
  if ( !retVal ) nSuccess++;
 
  std::cout << "Attempted 3 supersedes; # success = " << nSuccess << std::endl;
  return nSuccess;
}
 
int doSupersede( rdbModel::Rdb* rdb, rdbModel::Row& row, int serial, int* newSerial ) {
 
  std::string table( "metadata_v2r1" );
  int         retVal = -1;
 
  try
  {
    retVal = rdb->supersedeRow( table, row, serial, newSerial );
    if ( retVal )
    {
      std::cout << "supersede of row " << serial << " failed with code " << retVal
                << std::endl;
    }
    else { std::cout << "supsersede of row " << serial << " succeeded" << std::endl; }
  } catch ( rdbModel::RdbException ex )
  {
    std::cout << "supersede of row " << serial << " failed with exception " << std::endl;
    std::cout << ex.getMsg() << std::endl;
  }
  return retVal;
}