IOManagerDB.cpp

#include "IOManagerDB.h"
#include "IONameDB.h"
#include "MySqlException.h"
#include "ZlibStringCompressor.h"
#include "Sct/Serializable.h"
#include "Sct/SctNames.h"
#include "Sct/XmlStyleStream.h"
#include "Sct/StdExceptionWrapper.h"
#include "Sct/Archive/IONameArchiveFile.h"

#include "Sct/UniqueID.h"
#include "SctData/ScanResult.h"
#include "SctData/TestResult.h"
#include "CalibrationController/Serialization/IsInfoWrapper.h"
#include "CalibrationController/Serialization/TestDataWrapper.h"
#include <sstream>
#include "boost/lexical_cast.hpp"

using std::string;
using std::ostringstream;
using boost::shared_ptr;
using namespace Sct;

namespace SctArchiving {
//-------------------- Error handling --------------------//
  MysqlException::MysqlException(const string& msg, const string& file, int line){
    initialize("MYSQL_EXCEPTION", "ArchivingService::MysqlException", msg, 0, file, line);
  }
  MysqlException::MysqlException(const string& msg, const string& query, const string& file, int line) {
    std::ostringstream full_message;
    full_message << msg << "\nwhile executing query:\n" << query;
    initialize("MYSQL_EXCEPTION", "ArchivingService::MysqlException", full_message.str(), 0, file, line);
  }
  
  MysqlException::MysqlException(){}
  
  MysqlException::~MysqlException() throw(){}
  
  void IOManagerDB::checkForMySqlErrors(const string& msg, const string& file, int line) const{
    if(mysql_errno(m_mysql)){
      std::ostringstream full_message;
      full_message << msg << "\n" 
           << mysql_error(m_mysql) << "\n";
      std::cerr << "ERROR: " << full_message.str() << "\nat " << file << ":" << line << std::endl;
      throw MysqlException(full_message.str(), file, line);
    }
  }
  
  void IOManagerDB::checkForMySqlErrors(const string& msg, const string& query, const string& file, int line) const{
    if(mysql_errno(m_mysql)){
      std::ostringstream full_message;
      full_message << msg << "\n" 
                   << query << "\n"
           << mysql_error(m_mysql) << "\n";
//      std::cerr << "ERROR: " << full_message.str()
//      << "\n executing: "
//      << query
//      << "\nat " << file << ":" << line << std::endl;
//      throw MysqlException(full_message.str(), query, file, line);
      throw MysqlException(full_message.str(), file, line);
    }
  }
//-------------------- Error handling --------------------//

//-------------------- Constructors, destructors, instance management --------------------//
  IOManagerDB::IOManagerDB() : m_dataSetName("nowhere"), 
                   m_nRead(0), m_nWrite(0), 
                   m_nCompress(0), m_nDecompress(0), 
                   read_time(0,0,0,0), write_time(0,0,0,0),
                   compress_time(0,0,0,0), decompress_time(0,0,0,0)
  {
    
    std::cout <<"Creating IOManagerDB" << std::endl;
    m_compressor = shared_ptr<ZlibStringCompressor>(new ZlibStringCompressor());
    m_mysql = mysql_init((MYSQL*) 0);
    checkForMySqlErrors("Problem during initialisation of MYSQL structure.", __FILE__, __LINE__);
    
    // connect to the server
    std::cout <<"Connecting IOManagerDB" << std::endl;
    mysql_real_connect(m_mysql, "localhost", "daquser", "", NULL, 3306, NULL, 0);
    checkForMySqlErrors("Failed to connect to mysql server", __FILE__, __LINE__);
    SctNames::Mrs() << MRS_TEXT("Have connected to mysql server") << "IOMANAGER_DB_CONNECT" 
                    << MRS_INFORMATION << ENDM;

    // connect to the database
    std::string dbname="test_dbSRD";
    std::cout <<"Connecting IOManagerDB to database name=`" << dbname << "'" << std::endl;
    mysql_select_db(m_mysql, dbname.c_str());
    std::string message("Failed to connect to database");
    message += dbname;
    checkForMySqlErrors(message, __FILE__, __LINE__);
    SctNames::Mrs() << MRS_TEXT("Have connected to mysql database") << "IOMANAGER_DB_CONNECT" 
                    << MRS_PARAM<const char*>("database_name",dbname.c_str())
                    << MRS_INFORMATION << ENDM;
  }
  
  IOManagerDB::~IOManagerDB(){
#warning "AJB This never seems to get called because the manager is a static beast. **Hopefully** this dosent matter!"
    std::string message("Closing connection to mysql server");
    std::cout << message << endl;
    SctNames::Mrs() << MRS_TEXT(message) << "IOMANAGER_DB_CONNECT" 
                    << MRS_INFORMATION << ENDM;
    mysql_close(m_mysql);
  }

  IOManagerDB* IOManagerDB::s_man=0;

  IOManagerDB& IOManagerDB::instance() {
    if (!s_man) s_man=new IOManagerDB();
    return *s_man;
  }
//-------------------- Constructors, destructors, instance management --------------------//

//-------------------- String compressor stuff, not used yet --------------------//
//JD: This one should return proper status info, like...what??
  std::string IOManagerDB::status() const {
    std::ostringstream oss;
    oss << "IOManagerDB";
    if (m_compressor.get()){
      oss << "String compressor buffer size: " 
      << m_compressor->getBufferSize() << std::endl;
    }
    else {
      oss << "String compressor not initialized" << endl;
    }
    {
      boost::recursive_mutex::scoped_lock lock (getMutex());      
      oss << "write time " << write_time << " for " << m_nWrite;
      oss << endl;
      
      oss << "read time " << read_time << " for " << m_nRead;
      oss << endl;

      oss << "compress time " << compress_time << " for " << m_nCompress;
      oss << endl;
      
      oss << "decompress time " << decompress_time << " for " << m_nDecompress;
      oss << endl;
      
      oss << "blob-add time " << blob_add_time << " for " << m_nBlobAdd;
      oss << endl;

      oss << "ostream time " << ostream_time << " for " << m_nWrite;
      oss << endl;
      
      oss << "istream time " << istream_time << " for " << m_nRead;
      oss << endl;
      
    }
    return oss.str();
  }

//JD: Maybe not needed??
  const SctData::ResultHeader& IOManagerDB::getHeader(const Serializable& ob){
    const SctData::ResultHeader* header=0;
    if (ob.getClassName().find("TestResult")!=string::npos) {
      header = & dynamic_cast<const SctData::TestResult&>(ob).getHeader();
    } 
    if (ob.getClassName().find("ScanResult")!=string::npos) {
      header = & dynamic_cast<const SctData::ScanResult&>(ob).getHeader();
    }
    if (header) {
      return *header;
    } else {
      ostringstream oss;
      oss << "Dont know how to find a header for object with class name : " 
      << ob.getClassName() << " which has UniqueID : " 
      << (string) ob.getUniqueID();
      throw IoException(oss.str(), __FILE__, __LINE__);
    }
  }

//JD: Maybe not needed??
  string IOManagerDB::getTable(const Serializable& ob){
    return "data";
  }
//-------------------- String compressor stuff, not used yet --------------------//

//-------------------- Read and write interface to clients --------------------//
  void IOManagerDB::write(const Serializable& ob, const IOParams* par) const {
    using namespace boost::posix_time;
    ptime write_start_time(microsec_clock::local_time());
    using SctCalibrationController::IsInfoWrapper;

    try{
      boost::recursive_mutex::scoped_lock lock (getMutex());
      setReadMode(false);  // for version control
      
      std::ostringstream oss;
      Sct::XmlStyleOStream out_ad(oss);
      
      ptime ostream_start_time(microsec_clock::local_time());
      writeImpl(out_ad, ob, false);
      {
    ptime ostream_end_time(microsec_clock::local_time());
    boost::recursive_mutex::scoped_lock lock(timingAccess);
    ostream_time=ostream_time+(ostream_end_time-ostream_start_time);
      }
      
      // Get header info from object
      const std::string classname = ob.getClassName();
      const Sct::UniqueID id = ob.getUniqueID();

// Debug couts
std::cout << "IOMwrite - str(id)    : " << (std::string)id << std::endl;
std::cout << "IOMwrite - DataSetName: " << getDataSetName()  << std::endl;
std::cout << "IOMwrite - ClassName  : " << classname << std::endl;
std::cout << "IOMwrite - Scan#      : " << id.getScanNumber() << std::endl;
std::cout << "IOMwrite - Run#       : " << id.getRunNumber() << std::endl;

      // Get the runID
      std::string runId = getRunID(id.getRunNumber());

      // Check which type of object we are dealing with
      if (classname == "TestData"){
        // Cast Serializable into a Wrapper; will throw std::bad_cast if not possible
        const IsInfoWrapper& wrapper = dynamic_cast<const IsInfoWrapper&>(ob);

        // Get the wrapped object
        boost::shared_ptr<const ISInfo> info = wrapper.getWrapped();
        if (info.get() == 0){
// TODO: throw something
std::cout << "IOMwrite - debug msg, failed to get wrapped object" << std::endl;
        }

        // Cast into TestData
        boost::shared_ptr<const TestData> td = boost::dynamic_pointer_cast<const TestData>(info); 
        if (td.get() == 0){
// TODO: throw something
std::cout << "IOMwrite - debug msg, cast into TestData failed" << std::endl;
        }

        // Add run to db if it does not exist there already
        if (runId == ""){
          addRun(id.getRunNumber(), false);
// TODO: Check for errors???
          runId = getRunID(id.getRunNumber());
        }

    // Check if the test exist in the db
        std::string testId = getTestID(runId, id.getScanNumber());
        if (testId == ""){
          addTest(*td, true);
// TODO: Check for errors???
          testId = getTestID(runId, id.getScanNumber());
        }

        // Loop over all modules in this TestData object
        for (unsigned int i=0; i < (*td).modules_size; ++i) {
          // Check if the module exist in the db, add if not
          std::string moduleId = getModuleID((*td).modules[i]);
          if (moduleId == ""){
            // Add modules to db, assign to dummy position
            addModule("DummyLayer", "0", "0", (*td).modules[i]);
            moduleId = getModuleID((*td).modules[i]);
          }
          // Loop over all scans in this TestData object
          for (unsigned int j=0; j < (*td).nScans; ++j) {
            // Add all mod-scan combinations to the tblRawData table
            std::string scanId = getScanID(testId, (*td).startScanNumber + j);
            addRawDataRecord(moduleId, scanId);
// TODO: Check for errors??? Duplication error?
          }
        }
      }
      else {  // else not a TestData object
        // Throw exception if the run does not exist in the db
        if (runId == ""){
          ostringstream ossMsg;
          ossMsg << "The requested Run was not found in the db, runNr: " << id.getRunNumber();
          throw IoException(ossMsg.str(), __FILE__, __LINE__);
        }

        // Ask the db of the 1st scan# for the test of this scan
        unsigned firstScanNumber;
        std::ostringstream select;
        select << "SELECT Max(FirstScanNr) FROM tblTests "
               << "WHERE ((FirstScanNr <= " << id.getScanNumber() << ") "
               << "AND (RunID = " << runId << ")) "
               << "GROUP BY RunID ";
        firstScanNumber = boost::lexical_cast<int>(executeQueryReturnID(select.str()));

        // Check if the test exist in the db
        std::string testId = getTestID(runId, firstScanNumber);
        if (testId == ""){
// TODO: throw exception here...
std::cout << "IOMwrite - debug msg, oops, this test is not in the db" << std::endl;
        }

    // Check if the scan exist in the db (it should have been added with the test)
        std::string scanId = getScanID(testId, id.getScanNumber());
        if (scanId == ""){
          ostringstream ossMsg;
          ossMsg << "The requested Scan was not found in the db (runNr: " << id.getRunNumber()
                << ", firstScanNr: " << firstScanNumber
                << ", ScanNr: " << id.getScanNumber() << ")";
          throw IoException(ossMsg.str(), __FILE__, __LINE__);
        }

        // Check if the module exist in the db
        std::string moduleId = getModuleID(id.getModule());
        if (moduleId == ""){
          ostringstream ossMsg;
          ossMsg << "The requested Module was not found in the db, modNr: " << id.getModule();
          throw IoException(ossMsg.str(), __FILE__, __LINE__);
        }

        // Everything is ok in the db, store the data as a BLOB for this mod-scan
        const std::string& uncompressed = oss.str();
    ptime compress_start_time(microsec_clock::local_time());
        const std::string compressed = m_compressor->compress(uncompressed, getCompressionLevel());
    {
      ptime compress_end_time(microsec_clock::local_time());
      boost::recursive_mutex::scoped_lock lock(timingAccess);
      compress_time=compress_time+(compress_end_time-compress_start_time);
      m_nCompress++;
    }
    
    ptime blob_add_start_time(microsec_clock::local_time());
        addRawDataBlob(moduleId, scanId, compressed.c_str(), compressed.size());
    {
      ptime blob_add_end_time(microsec_clock::local_time());
      boost::recursive_mutex::scoped_lock lock(timingAccess);
      blob_add_time=blob_add_time+(blob_add_end_time-blob_add_start_time);
      m_nBlobAdd++;
    }

// Debug couts
std::cout << "IOMwrite - 1stScan# : " << firstScanNumber << std::endl;
std::cout << "IOMwrite - RunID    : " << runId << std::endl;
std::cout << "IOMwrite - ModID    : " << moduleId << std::endl;
std::cout << "IOMwrite - TestID   : " << testId << std::endl;
std::cout << "IOMwrite - ScanID   : " << scanId << std::endl;
      }
    }catch (Sct::Throwable& e){
      throw; // pass up to next level
    }catch(std::exception& e){
      StdExceptionWrapper sew(e);
      throw IoException(sew, __FILE__, __LINE__);
    }

    {
      ptime write_end_time(microsec_clock::local_time());
      boost::recursive_mutex::scoped_lock lock(timingAccess);
      write_time=write_time+(write_end_time-write_start_time);
      m_nWrite++;
    }
  }


  boost::shared_ptr<Serializable> IOManagerDB::read(const string& name, const IOParams* par) const {
    using namespace boost::posix_time;
    ptime read_start_time(microsec_clock::local_time());
    
    using SctCalibrationController::TestDataWrapper;
   try{
      boost::recursive_mutex::scoped_lock lock (getMutex());
      setReadMode(true);           // for version control
      getReadVersionMap().clear(); // for version control

      const IONameDB ioname(name);
      const Sct::UniqueID id = ioname.getUniqueID();
      const std::string classname = ioname.getClassName();

      // Create pointer which will be returned at then end of this method
      boost::shared_ptr<Serializable> p_ob;

// Debug couts
std::cout << "IOMread - name       : " << name << std::endl;
std::cout << "IOMread - str(id)    : " << (std::string)id << std::endl;
std::cout << "IOMread - DataSetName: " << getDataSetName()  << std::endl;
std::cout << "IOMread - ClassName  : " << classname << std::endl;
std::cout << "IOMread - Scan#      : " << id.getScanNumber() << std::endl;
std::cout << "IOMread - Run#       : " << id.getRunNumber() << std::endl;

      // Get the runID
      std::string runId = getRunID(id.getRunNumber());
      if (runId == ""){
        ostringstream oss;
        oss << "The requested Run was not found in the db, runNr: " << id.getRunNumber();
        throw IoException(oss.str(), __FILE__, __LINE__);
      }

      // Check which type of object we are dealing with
      if (classname == "TestData"){
        // Check if the test exist in the db
        std::string testId = getTestID(runId, id.getScanNumber());
        if (testId == ""){
          ostringstream oss;
          oss << "The requested Test was not found in the db (runNr: " << id.getRunNumber()
              << ", firstScanNr: " << id.getScanNumber() << ")";
          throw IoException(oss.str(), __FILE__, __LINE__);
        }

        // Create a TestData object
        boost::shared_ptr<TestData> td(new TestData()); 
    
/*
TODO:
 - Fill TestData object with scans, modules, etc, from the db
   + get startTime and endTime from tblTests
   + get n.o. scans for testId from tblScans
   + startScanNumber = id.getScanNumber()
   + runNumber = id.getRunNumber()
   + testName = Extract from classname???
   + get module_size from tblRawData (n.o. rows for one of the scans)
   + get modules (uhh, this will be a tricky SQL)
   + anything else (testPoints, testVariable, version)???
*/
        // Jorgen needs to fill this with useful stuff!
        td->testName="blah";
    
        boost::shared_ptr<TestDataWrapper> wrapper(new TestDataWrapper(td));
    {
      ptime read_end_time(microsec_clock::local_time());
      boost::recursive_mutex::scoped_lock lock(timingAccess);
      read_time=read_time+(read_end_time-read_start_time);
      m_nRead++;
    }
        return wrapper;
      }
      else if (classname == "SctData::RawScanResult"){
        // Ask the db of the 1st scan# for the test of this scan
        unsigned firstScanNumber;
        std::ostringstream select;
        select << "SELECT Max(FirstScanNr) FROM tblTests "
               << "WHERE ((FirstScanNr <= " << id.getScanNumber() << ") "
               << "AND (RunID = " << runId << ")) "
               << "GROUP BY RunID ";
        firstScanNumber = boost::lexical_cast<int>(executeQueryReturnID(select.str()));

        // Check if the test exist in the db
        std::string testId = getTestID(runId, firstScanNumber);
        if (testId == ""){
// TODO: throw exception here...
std::cout << "IOMwrite - debug msg, oops, this test is not in the db" << std::endl;
        }

        // Check if the scan exist in the db (it should have been added with the test)
        std::string scanId = getScanID(testId, id.getScanNumber());
        if (scanId == ""){
          ostringstream oss;
          oss << "The requested Scan was not found in the db (runNr: " << id.getRunNumber()
              << ", firstScanNr: " << firstScanNumber
              << ", ScanNr: " << id.getScanNumber() << ")";
          throw IoException(oss.str(), __FILE__, __LINE__);
        }

        // Check if the module exist in the db
        std::string moduleId = getModuleID(id.getModule());
        if (moduleId == ""){
          ostringstream oss;
          oss << "The requested Module was not found in the db, modNr: " << id.getModule();
          throw IoException(oss.str(), __FILE__, __LINE__);
        }

// Debug couts
std::cout << "IOMread - 1stScan# : " << firstScanNumber << std::endl;
std::cout << "IOMread - RunID    : " << runId << std::endl;
std::cout << "IOMread - ModID    : " << moduleId << std::endl;
std::cout << "IOMread - TestID   : " << testId << std::endl;
std::cout << "IOMread - ScanID   : " << scanId << std::endl;

        // Get the desired data from the db
        std::string compressed;
        compressed = getRawDataBlob(moduleId, scanId);

        // Inflate and return the string
    ptime decompress_start_time(microsec_clock::local_time());
        const std::string uncompressed = m_compressor->inflate(compressed);
    {
      ptime decompress_end_time(microsec_clock::local_time());
      boost::recursive_mutex::scoped_lock lock(timingAccess);
      decompress_time=decompress_time+(decompress_end_time-decompress_start_time);
      m_nDecompress++;
    }

        std::istringstream iss(uncompressed);
        XmlStyleIStream in_ad(iss);

    ptime istream_start_time(microsec_clock::local_time());
        p_ob = boost::dynamic_pointer_cast<Serializable>(readImpl(in_ad));
    {
      ptime istream_end_time(microsec_clock::local_time());
      boost::recursive_mutex::scoped_lock lock(timingAccess);
      istream_time=istream_time+(istream_end_time-istream_start_time);
    }
      }
      else if (classname == "SctData::FitScanResult"){
// TODO: fill tblFittedData here
    throw Sct::LogicError("not implimented!", __FILE__, __LINE__);
      }
      else if (classname == "xxxTestResult"){
// TODO: fill tblAnalysedData here
    throw Sct::LogicError("not implimented!", __FILE__, __LINE__);
      }
      else {  // unkown object
        ostringstream oss;
        oss << "Unknown Class name: " << classname;
        throw IoException(oss.str(), __FILE__, __LINE__);
      }

      {
    ptime read_end_time(microsec_clock::local_time());
    boost::recursive_mutex::scoped_lock lock(timingAccess);
    read_time=read_time+(read_end_time-read_start_time);
    m_nRead++;
      }
      return p_ob;
      // Catch exceptions
    }catch (Sct::Throwable& e) {
      throw; // pass up to next level
    }catch(std::exception& e){
      StdExceptionWrapper sew(e);
      throw IoException(sew, __FILE__, __LINE__);
    }
  }
//-------------------- Read and write interface to clients --------------------//

//-------------------- Utility methods --------------------//
std::string IOManagerDB::convertToMysqlDateTimeFormat(const std::string& original){
  std::string copy=original;
  unsigned t = copy.find('T');
  if (copy.empty()) {
    // Some tests seems to miss the end date-time. Return a '0' date-time for these cases
    copy = "0000-00-00 00:00:00";
  } else if (t==string::npos) {
    //Ooops, no 'T' found in string, throw!
    std::ostringstream msg;
    msg << "could not parse date/time since I couldn't find a `T' in " << copy;
    throw Sct::IoException(msg.str(), __FILE__, __LINE__);
  } else {
    // This looks like a proper date-time string
    copy = copy.erase(t,1);
  }
  return copy;
}

void IOManagerDB::setDataSetName(const std::string& name){
  m_dataSetName=name;
}

std::string IOManagerDB::getDataSetName() const{
  return m_dataSetName;
}
//-------------------- Utility methods --------------------//

//-------------------- Get-an-ID methods --------------------//
std::string IOManagerDB::getDataSetID() const{
  std::ostringstream select;
  select << "SELECT DataSetID FROM tblDataSets WHERE "
         << "(DataSetName = '" << getDataSetName() << "')";
  return executeQueryReturnID(select.str());
}

std::string IOManagerDB::getTestTypeID(const std::string& testName) const{
  std::ostringstream select;
  select << "SELECT TestTypeID FROM tblTestTypes WHERE "
         << "(TestTypeName = '" << testName << "')";
  return executeQueryReturnID(select.str());
}

std::string IOManagerDB::getRunID(const unsigned runNumber) const{
  std::ostringstream select;
  select << "SELECT RunID FROM tblRuns WHERE "
         << "(DataSetID = " << getDataSetID() << ") AND "
         << "(RunNr = " << runNumber << ")";  
  return executeQueryReturnID(select.str());
}

std::string IOManagerDB::getTestID(const std::string& runId, 
                   const unsigned firstScanNumber) const{
  std::ostringstream select;
  select << "SELECT TestID FROM tblTests WHERE "
         << "(RunID = " << runId << ") AND "
     << "(FirstScanNr = " << firstScanNumber << ")";
  return executeQueryReturnID(select.str());
}

std::string IOManagerDB::getScanID(const std::string& testId,
                                   const unsigned scanNumber) const{
  std::ostringstream select;
  select << "SELECT ScanID FROM tblScans WHERE "
         << "(TestID = " << testId << ") AND "
     << "(ScanNr = " << scanNumber << ")";
  return executeQueryReturnID(select.str());
}

std::string IOManagerDB::getLayerID(const std::string& layerName) const{
  std::ostringstream select;
  select << "SELECT LayerID FROM tblLayers WHERE "
     << "(LayerName = " << "'" << layerName << "'" << ")";
  return executeQueryReturnID(select.str());
}

std::string IOManagerDB::getRowID(const std::string& layerId,
                                  const std::string& LMTnr) const{
  std::ostringstream select;
  select << "SELECT RowID FROM tblRows WHERE "
         << "(LayerID = " << layerId << ") AND "
     << "(LMTNr = " << "'" << LMTnr << "'" << ")";
  return executeQueryReturnID(select.str());
}

std::string IOManagerDB::getPositionID(const std::string& rowId,
                                       const std::string& positionNumber) const{
  std::ostringstream select;
  select << "SELECT PositionID FROM tblPositions WHERE "
         << "(RowID = " << rowId << ") AND "
     << "(PositionNr = " << "'" << positionNumber << "'" << ")";
  return executeQueryReturnID(select.str());
}

std::string IOManagerDB::getModuleID(const std::string& moduleNumber) const{
  std::ostringstream select;
  select << "SELECT ModuleID FROM tblModules WHERE "
     << "(ModuleNr = " << "'" << moduleNumber << "'" << ")";
  return executeQueryReturnID(select.str());
}
//-------------------- Get-an-ID methods --------------------//

//-------------------- Add-to-db methods --------------------//
void IOManagerDB::addRun(unsigned long runNumber, bool trash) const{
  std::ostringstream select;
  select << "INSERT INTO tblRuns \n"
     << "(DataSetID, RunNr, Trash) \n"
         << "VALUES ( \n"
         << getDataSetID() << ", " << runNumber << ", " << trash << ")";

  executeQuery(select.str());

  if (mysql_affected_rows(m_mysql)!=1){
    throw MysqlException("Did NOT add row", select.str(), __FILE__, __LINE__);
  }
}

void IOManagerDB::addTest(const TestData& testdata, bool alsoAddScans) const{
  std::ostringstream select;
  select << "INSERT INTO tblTests \n"
     << "(RunID, TestTypeID, FirstScanNr, StartTime, EndTime) \n"
         << "VALUES ( \n"
         << getRunID(testdata.runNumber) << ", "
         << getTestTypeID(testdata.testName) << ", "
         << testdata.startScanNumber << ", "
     << "'" << convertToMysqlDateTimeFormat(testdata.startTime) << "', "
     << "'" << convertToMysqlDateTimeFormat(testdata.endTime) << "')";

  executeQuery(select.str());

  if (mysql_affected_rows(m_mysql)!=1){
    throw MysqlException("Did NOT add row", select.str(), __FILE__, __LINE__);
  }
  if (alsoAddScans){
    for (unsigned iscan=testdata.startScanNumber; 
     iscan < (testdata.startScanNumber + testdata.nScans);
     ++iscan){
      addScan(testdata, iscan);
    }
  }
}

void IOManagerDB::addScan(const TestData& testdata, unsigned scanNumber) const{
  std::ostringstream select;
  std::string runId = getRunID(testdata.runNumber);
  select << "INSERT INTO tblScans \n"
     << "(TestID, ScanNr) \n"
         << "VALUES ( \n"
         << getTestID(runId, testdata.startScanNumber) << ", "
         << scanNumber << ")";

  executeQuery(select.str());

  if (mysql_affected_rows(m_mysql)!=1){
    throw MysqlException("Did NOT add row", select.str(), __FILE__, __LINE__);
  }
}

void IOManagerDB::addModule(const std::string& layerName,
                            const std::string& LMTnr,
                            const std::string& positionNumber,
                            const std::string& moduleNumber) const{
  std::ostringstream select;
  std::string layerId = getLayerID(layerName);
  std::string rowId = getRowID(layerId, LMTnr);
  std::string positionId = getPositionID(rowId, positionNumber);

  select << "INSERT INTO tblModules \n"
     << "(PositionID, ModuleNr) \n"
         << "VALUES (" << positionId << ", "
         << "'" << moduleNumber<< "'" << ")";

  executeQuery(select.str());

  if (mysql_affected_rows(m_mysql)!=1){
    throw MysqlException("Did NOT add row", select.str(), __FILE__, __LINE__);
  }
}

void IOManagerDB::addRawDataRecord(const std::string& moduleId, const std::string& scanId) const{
  std::ostringstream insert;

  insert << "INSERT INTO tblRawData \n"
         << "(ModuleID, ScanID) \n"
         << "VALUES ( \n"
         << moduleId << ", "
         << scanId << ")";

  mysql_query(m_mysql, insert.str().c_str());
  checkForMySqlErrors("Cannot execute: ", insert.str(), __FILE__, __LINE__);
  if (mysql_affected_rows(m_mysql)!=1){
    throw MysqlException("Did NOT add row", insert.str(), __FILE__, __LINE__);
  }
}

void IOManagerDB::addRawDataBlob(const std::string& moduleId, const std::string& scanId,
                     const char *chBuf, const long bufSize) const{

// Somebody (Alan?) should have a look at the handling of the buffers here...

// Get file size & create a buffer of that size
//    long bufSize = rawDataBlob.size();
//    char *chBuf = new char [bufSize];

  // Start of query string
  char chMySql[1000000] = "UPDATE tblRawData SET RawDataBlob = '";

  // Pointer to end of query string
  char* chTail;
  chTail = chMySql + strlen(chMySql);

  // Check if buffer is large enough
  if ((chTail + 2*bufSize) + 3 > chMySql + sizeof(chMySql)) {
    throw MysqlException("Buffer to small for binary data", __FILE__, __LINE__);
  }

  // Add binary data to the query string
  chTail += mysql_real_escape_string(m_mysql, chTail, chBuf, bufSize);

  // End of query string
  std::string sqlEnd;
  sqlEnd = "' WHERE (ModuleID = " + moduleId + ") AND (" + "ScanID = " + scanId + ")";
  (void) strcpy (chTail, sqlEnd.c_str());

  // Write to MySQL db
  mysql_real_query(m_mysql, chMySql, strlen(chMySql));
  checkForMySqlErrors("Cannot execute: ", "...(binary data)..." + sqlEnd, __FILE__, __LINE__);

  // Check if exactly one row were updated. Note: this check seems to fail if exactly the same 
  //  binary contents in the buffer already exists in the db!? (How can the MySQL engine check this?)
  if (mysql_affected_rows(m_mysql) != 1){
    throw MysqlException("Did NOT update row", "...(binary data)..." + sqlEnd, __FILE__, __LINE__);
  }
}
//-------------------- Add-to-db methods --------------------//

//-------------------- Read-from-db methods --------------------//
std::string IOManagerDB::getRawDataBlob(const std::string& moduleId,
                                        const std::string& scanId) const{

  // MySQL variables. Use that boost stuff??
//  shared_ptr<MYSQL_RES> rsBin;
  MYSQL_RES* rsBin; 
  MYSQL_ROW  rwBin; 

// Create SQL string which retrieves the blob
  string sSQL;
  sSQL = "SELECT RawDataBlob FROM tblRawData WHERE (ModuleID = "
       + moduleId + ") AND (" + "ScanID = " + scanId + ")";

// First check is the blob contains NULL (otherwise problems later with mysql_fetch_row)
  string sIsNullSQL;
  sIsNullSQL = "SELECT (" + sSQL + ") IS NULL";

  // Read data from MySQL db
  mysql_real_query(m_mysql, sIsNullSQL.c_str(), strlen(sIsNullSQL.c_str())); 
  checkForMySqlErrors("Cannot execute: ", sIsNullSQL, __FILE__, __LINE__);

  // Store the result
  rsBin = mysql_store_result(m_mysql); 
  checkForMySqlErrors("Can't store the result of query: ", sIsNullSQL, __FILE__, __LINE__);

  // Get the row (there should be only one row in the recordset)
  rwBin = mysql_fetch_row(rsBin); 
  checkForMySqlErrors("Can't fetch the first row of query: ", sIsNullSQL, __FILE__, __LINE__);

  // If the blob is not null, then the query will be "0".
  if ((string)rwBin[0] != "0"){
    std::cout << "Oops, blob is null in the db. Returning zero-length-string" << std::endl;
    return "";
  }

  // Now read the blob itself from the db
  mysql_real_query(m_mysql, sSQL.c_str(), strlen(sSQL.c_str())); 
  checkForMySqlErrors("Cannot execute: ", sSQL, __FILE__, __LINE__);

// Debug cout
std::cout << "getRawDataBlob: Binary data read from the MySQL db." << std::endl;

  // Store the result
  rsBin = mysql_store_result(m_mysql); 
  checkForMySqlErrors("Can't store the result of query: ", sSQL, __FILE__, __LINE__);

// Debug cout
std::cout << "getRawDataBlob: Recordset retrieved successfully." << std::endl;

  // Get number of rows in the record set
  int iNrOfRows = (int) mysql_num_rows(rsBin);

// Debug cout
std::cout << "getRawDataBlob: Number of records in recordset: " << iNrOfRows << std::endl;

  // Get the row (there should be only one row in the recordset)
  rwBin = mysql_fetch_row(rsBin); 
  checkForMySqlErrors("Can't fetch the first row of query: ", sSQL, __FILE__, __LINE__);

  // Copy the result to a str::string.
  // Careful, the result may contain NULL characters: use string(charArray, length) syntax
  unsigned long *lSize; 
  lSize = mysql_fetch_lengths(rsBin); 
  string sBin(rwBin[0], lSize[0]);

// Debug cout
std::cout << "getRawDataBlob: Size of blob: " << lSize[0] << endl;

  // Release the space allocated by mysql_store_data
  mysql_free_result(rsBin);

  // Close and return string with blob
  return sBin;
}

//-------------------- Read-from-db methods --------------------//

//-------------------- Stuff to execute query --------------------//

void IOManagerDB::executeQuery(std::string query) const {
  using namespace boost::posix_time;
  ptime query_start_time(microsec_clock::local_time());
  
  mysql_query(m_mysql, query.c_str());

  {
    ptime query_end_time(microsec_clock::local_time());
    boost::recursive_mutex::scoped_lock lock(timingAccess);
    query_time=query_time+(query_end_time-query_start_time);
    m_nQueries++;
  }

  checkForMySqlErrors("Cannot execute: ", query, __FILE__, __LINE__);

}


std::string IOManagerDB::executeQueryReturnID(std::string query) const{
  executeQuery(query);
  
  shared_ptr<MYSQL_RES> result = getResult();
  
  unsigned nmatch = mysql_num_rows(result.get());
  if (nmatch != 1){
    return "";
  }
  MYSQL_ROW row = mysql_fetch_row(result.get());
  checkForMySqlErrors("Can't fetch the first row of query: ", query, __FILE__, __LINE__);
  return row[0];
}

boost::shared_ptr<MYSQL_RES> IOManagerDB::getResult() const{
  if (!m_mysql) throw Sct::LogicError("m_mysql not initialised!", __FILE__, __LINE__);

  MySqlFreeResultDeleter d;
  shared_ptr<MYSQL_RES> result (mysql_store_result(m_mysql), d);
  checkForMySqlErrors("Error storing result", __FILE__, __LINE__);  
  return result;
}

void IOManagerDB::MySqlFreeResultDeleter::operator () (MYSQL_RES* result) throw() {
  //std::cout << "  IOManagerDB::MySqlFreeResultDeleter operator () called ! yippee! " << std::endl;
  mysql_free_result(result);
//-------------------- Stuff to execute query --------------------//
}

} //End of namespace SctArchiving

---