/data/refman/pasoursint/CMSSW_5_3_6/src/OnlineDB/EcalCondDB/src/LMFDat.cc

Go to the documentation of this file.

#include "OnlineDB/EcalCondDB/interface/LMFDat.h"

#include <sstream>
#include <math.h>

using std::cout;
using std::endl;

LMFDat::LMFDat() : LMFUnique() { 
  m_tableName = ""; 
  m_max = -1; 
  _where = "";
  _wherePars.clear();
}

LMFDat::LMFDat(EcalDBConnection *c) : LMFUnique(c) {
  m_tableName = "";
  m_max = -1;
  _where = "";
  _wherePars.clear();
}

LMFDat::LMFDat(oracle::occi::Environment* env,
               oracle::occi::Connection* conn) : LMFUnique(env, conn) {
  m_tableName = "";
  m_max = -1;
  _where = "";
  _wherePars.clear();
}

std::string LMFDat::foreignKeyName() const {
  return "lmfRunIOV";
}

int LMFDat::getLMFRunIOVID() {
  int id = getInt(foreignKeyName());
  if (id == 0) {
    // try to get it from the list of foreign keys
    std::map<std::string, LMFUnique*>::iterator i = 
      m_foreignKeys.find(foreignKeyName());
    if (i != m_foreignKeys.end()) {
      LMFRunIOV *iov = (LMFRunIOV*)(i->second);
      if (iov != NULL) {
        id = iov->fetchID();
        setInt(foreignKeyName(), id);
      }
    }
  }
  return id;
}

LMFDat& LMFDat::setMaxDataToDump(int n) {
  m_max = n;
  return *this;
}

std::map<unsigned int, std::string> LMFDat::getReverseMap() const {
  std::map<unsigned int, std::string> m;
  std::map<std::string, unsigned int>::const_iterator i = m_keys.begin();
  std::map<std::string, unsigned int>::const_iterator e = m_keys.end();
  while (i != e) {
    m[i->second] = i->first;
    i++;
  }
  return m;
}

void LMFDat::dump() const {
  dump(0, m_max);
}

void LMFDat::dump(int n) const {
  dump(n, m_max);
}

void LMFDat::dump(int n, int max) const {
  LMFUnique::dump(n);
  int s = m_data.size();
  cout << "Stored data: " << s << endl;
  if (max >= 0) {
    std::map<int, std::vector<float> >::const_iterator p = m_data.begin();
    std::map<int, std::vector<float> >::const_iterator end = m_data.end();
    int c = 0;
    std::map<unsigned int, std::string> rm = getReverseMap();
    while ((p != end) && (c < max)) {
      int id = p->first;
      std::vector<float> x = p->second;
      cout << c << " -------------------------------------------" << endl;
      cout << "   ID: " << id << endl;
      for (unsigned int j = 0; j < x.size(); j++) {
        if (j % 4 == 0) {
          cout << endl << "   ";
        }
        cout << rm[j] << ":" << x[j] << "\t";
      }
      cout << endl;
      p++;
      c++;
    }
  }
}

std::string LMFDat::buildInsertSql() {
  // create the insert statement
  std::stringstream sql;
  sql << "INSERT INTO " + getTableName() + " VALUES (";
  unsigned int nParameters = m_keys.size() + 2; 
  for (unsigned int i = 0; i < nParameters - 1; i++) {
    sql << ":" << i + 1 << ", ";
  }
  sql << ":" << nParameters << ")";
  std::string sqls = sql.str();
  if (m_debug) {
    cout << m_className << "::writeDB: " << sqls << endl;
  }
  return sqls;
}

std::string LMFDat::getIovIdFieldName() const {
  return "LMF_IOV_ID";
}

void LMFDat::setWhereClause(std::string where) {
  // to be used by experts to restrict the results of a query
  _where = where;
}

void LMFDat::setWhereClause(std::string where, 
                            std::vector<std::string> parameters) {
  // to be used by experts to restrict the results of a query
  // in this case the where clause can contains positional parameter,
  // identified as :/I, :/S, :/F for, respectively, integer, string or
  // float parameters. The parameters are all passed as strings
  // in parameters
  _wherePars  = parameters;
  _where      = where;
}

std::string LMFDat::buildSelectSql(int logic_id, int direction) {
  // create the insert statement
  // if logic_id = 0 select all channels for a given iov_id
  std::stringstream sql;
  int count = 1;
  if (getLMFRunIOVID() > 0) {
    if (_where.length() > 0) {
      // check if this is an expert query. If so, add a WHERE clause
      _where = " AND " + _where;
    }
    // in this case we are looking for all data collected during the same
    // IOV. There can be many logic_ids per IOV.
    sql << "SELECT * FROM CMS_ECAL_LASER_COND." << getTableName() << " WHERE "
        << getIovIdFieldName() << " = " << getLMFRunIOVID() 
        << _where;
    // the expert query must be specified each time the expert makes the query
    // then empty it
    _where = "";
  } else {
    // in this case we are looking for a specific logic_id whose
    // data have been collected at a given time. There is only
    // one record in this case.
    std::string op = ">";
    std::string order = "ASC";
    if (direction < 0) {
      op = "<";
      order = "DESC";
    }
    sql << "SELECT * FROM (SELECT CMS_ECAL_LASER_COND." 
        << getTableName() << ".* FROM CMS_ECAL_LASER_COND." 
        << getTableName() 
        << " JOIN LMF_RUN_IOV ON " 
        << "LMF_RUN_IOV.LMF_IOV_ID = " 
        << getTableName() << "." << getIovIdFieldName() << " "
        << "WHERE SUBRUN_START " << op << "= TO_DATE(:" << count;
    count++;
    sql << ", 'YYYY-MM-DD HH24:MI:SS') ORDER BY SUBRUN_START " 
        << order << ") WHERE ROWNUM <= 1";
  }
  if (logic_id > 0) {
    sql << " AND LOGIC_ID = :" << count;
  }
  std::string sqls = sql.str();
  if (m_debug) {
    cout << m_className << "::buildSelectSqlDB: " << sqls << endl;
  }
  return sqls;
}

void LMFDat::getPrevious(LMFDat *dat)
  throw(std::runtime_error)
{
  getNeighbour(dat, -1);
}

void LMFDat::getNext(LMFDat *dat)
  throw(std::runtime_error)
{
  getNeighbour(dat, +1);
}

void LMFDat::getNeighbour(LMFDat *dat, int which)
  throw(std::runtime_error)
{
  // there should be just one record in this case
  if (m_data.size() == 1) {
    dat->setConnection(this->getEnv(), this->getConn());
    int logic_id = m_data.begin()->first;
    Tm lastMeasuredOn = getSubrunStart();
    lastMeasuredOn += which;
    dat->fetch(logic_id, &lastMeasuredOn, which);
    dat->setMaxDataToDump(m_max);
  } else {
    dump();
    throw(std::runtime_error(m_className + "::getPrevious: Too many LOGIC_IDs in "
                        "this object"));
  }
}

void LMFDat::fetch(const EcalLogicID &id) 
  throw(std::runtime_error)
{
  fetch(id.getLogicID());
}

void LMFDat::fetch(const EcalLogicID &id, const Tm &tm) 
  throw(std::runtime_error)
{
  fetch(id.getLogicID(), &tm, 1);
}

void LMFDat::fetch(const EcalLogicID &id, const Tm &tm, int direction) 
  throw(std::runtime_error)
{
  setInt(foreignKeyName(), 0); /* set the LMF_IOV_ID to undefined */
  fetch(id.getLogicID(), &tm, direction);
}

void LMFDat::fetch() 
  throw(std::runtime_error)
{
  fetch(0);
}

void LMFDat::fetch(int logic_id) 
  throw(std::runtime_error)
{
  fetch(logic_id, NULL, 0);
}

void LMFDat::fetch(int logic_id, const Tm &tm) 
  throw(std::runtime_error)
{
  fetch(logic_id, &tm, 1);
}

void LMFDat::adjustParameters(int count, std::string &sql, 
                              Statement *stmt) {
  // adjust positional parameters and change them according to their
  // decalred type
  std::size_t nw = 0;
  std::size_t n = sql.find(":"); 
  for (int done = 1; done < count; done++) {
    // skip already bound variables
    n = sql.find(":", n + 1);
  }
  while (n != std::string::npos) {
    char type = sql.at(n + 1);
    if (type == 'S') {
      stmt->setString(nw + count, _wherePars[nw]);
      nw++;
    } else if (type == 'F') {
      stmt->setFloat(nw + count, atof(_wherePars[nw].c_str()));
      nw++;
    } else if (type == 'I') {
      stmt->setInt(nw + count, atoi(_wherePars[nw].c_str()));
      nw++; 
    } 
    n = sql.find(":", n + 1); 
  }
}

void LMFDat::fetch(int logic_id, const Tm *timestamp, int direction) 
  throw(std::runtime_error)
{
  bool ok = check();
  if ((timestamp == NULL) && (getLMFRunIOVID() == 0)) {
    throw(std::runtime_error(m_className + "::fetch: Cannot fetch data with "
                        "timestamp = 0 and LMFRunIOV = 0"));
  }
  if (ok && isValid()) {
    if (m_debug) {
      std::cout << "[LMFDat] This object is valid..." << std::endl;
    }
    try {
      Statement * stmt = m_conn->createStatement();
      std::string sql = buildSelectSql(logic_id, direction);
      if (m_debug) {
        std::cout << "[LMFDat] Executing query " << std::endl;
        std::cout << "         " << sql << std::endl << std::flush;
      }
      if (logic_id == 0) {
        // get data for all crystals with a given timestamp
        stmt->setPrefetchRowCount(10000);
      }
      stmt->setSQL(sql);
      int count = 1;
      if (logic_id > 0) {
        if (timestamp != NULL) {
          stmt->setString(count, timestamp->str());
          count++;
        }
        stmt->setInt(count++, logic_id);
      }
      adjustParameters(count, sql, stmt);
      ResultSet *rset = stmt->executeQuery();
      std::vector<float> x;
      int nData = m_keys.size();
      x.reserve(nData);
      while (rset->next() != 0) {
        for (int i = 0; i < nData; i++) {
          x.push_back(rset->getFloat(i + 3));
        }
        int id = rset->getInt(2);
        if (timestamp != NULL) {
          setInt(foreignKeyName(), rset->getInt(1));
        }
        this->setData(id, x);
        x.clear();
      }
      stmt->setPrefetchRowCount(0);
      m_conn->terminateStatement(stmt);
    }
    catch (oracle::occi::SQLException &e) {
      throw(std::runtime_error(m_className + "::fetch: " + e.getMessage()));
    }
    m_ID = m_data.size();
  }
}

bool LMFDat::isValid() {
  bool ret = true;
  if (m_foreignKeys.find(foreignKeyName()) == m_foreignKeys.end()) {
    ret = false;
    m_Error += " Can't find lmfRunIOV within foreign keys.";
    if (m_debug) {
      cout << m_className << ": Foreign keys map size: " << m_foreignKeys.size() 
           << endl;
    }
  }
  return ret;
}

std::map<int, std::vector<float> > LMFDat::fetchData() 
  throw(std::runtime_error)
{
  // see if any of the data is already in the database
  std::map<int, std::vector<float> > s = m_data;
  std::string sql = "SELECT LOGIC_ID FROM CMS_ECAL_LASER_COND." + 
    getTableName() + " WHERE "
    + getIovIdFieldName() + " = :1";
  if (m_debug) {
    cout << m_className << ":: candidate data items to be written = " 
         << s.size() << endl;
    cout << m_className << "   Executing " << sql;
    cout << " where " << getIovIdFieldName() << " = " 
         << getLMFRunIOVID() << endl;
  }
  try {
    Statement* stmt = m_conn->createStatement();
    stmt->setSQL(sql);
    stmt->setInt(1, getLMFRunIOVID());
    stmt->setPrefetchRowCount(10000);
    ResultSet* rset = stmt->executeQuery();
    std::map<int, std::vector<float> >::iterator i = s.end();
    std::map<int, std::vector<float> >::iterator e = s.end();
    while (rset->next() != 0) {
      if (m_debug) {
        cout << m_className << ":: checking " << rset->getInt(1) << endl
             << std::flush;
      }
      i = s.find(rset->getInt(1));
      if (i != e) {
        s.erase(i);
      }
    }
    stmt->setPrefetchRowCount(0);
    m_conn->terminateStatement(stmt);
  }
  catch (oracle::occi::SQLException &e) {
    throw(std::runtime_error(m_className + "::fetchData:  "+e.getMessage()));
  }
  if (m_debug) {
    cout << m_className << ":: data items to write = " 
         << s.size() << endl;
  }
  return s;
}

int LMFDat::writeDB() 
  throw(std::runtime_error)
{
  // first of all check if data already present
  if (m_debug) {
    cout << m_className << ": Writing foreign keys" << endl;
  }
  LMFUnique::writeForeignKeys();
  if (m_debug) {
    cout << m_className << ": Foreign keys written" << endl;
  }
  // write data on the database
  int ret = 0;
  std::map<int, std::vector<float> > data2write = fetchData();
  if (data2write.size() > 0) {
    this->checkConnection();
    bool ok = check();
    // write
    if (ok && isValid()) {
      std::list<dvoid *> bufPointers;
      int nParameters = m_keys.size(); 
      int nData = data2write.size();
      if (m_debug) {
        cout << m_className << ": # data items = " << nData << endl;
        cout << m_className << ": # parameters = " << nParameters << endl;
      }
      int * iovid_vec = new int[nData];
      int * logicid_vec = new int[nData];
      int *intArray = new int[nData];
      float *floatArray = new float[nData];
      ub2 * intSize = new ub2[nData];
      ub2 * floatSize = new ub2[nData];
      size_t intTotalSize = sizeof(int)*nData;
      size_t floatTotalSize = sizeof(float)*nData;
      try {
        Statement * stmt = m_conn->createStatement();
        std::string sql = buildInsertSql();
        stmt->setSQL(sql);
        // build the array of the size of each column
        for (int i = 0; i < nData; i++) {
          intSize[i] = sizeof(int);
          floatSize[i] = sizeof(int);
        }
        // build the data array for first column: the same run iov id
        LMFRunIOV *runiov = (LMFRunIOV*)m_foreignKeys[foreignKeyName()];
        int iov_id = runiov->getID();
        std::map<int, std::vector<float> >::const_iterator b = data2write.begin();
        std::map<int, std::vector<float> >::const_iterator e = data2write.end();
        for (int i = 0; i < nData; i++) {
          iovid_vec[i] = iov_id;
        }
        stmt->setDataBuffer(1, (dvoid*)iovid_vec, oracle::occi::OCCIINT,
                            sizeof(iovid_vec[0]), intSize);
        // build the data array for second column: the logic ids
        int c = 0;
        while (b != e) {
          int id = b->first;
          logicid_vec[c++] = id;
          b++;
        }
        stmt->setDataBuffer(2, (dvoid*)logicid_vec, oracle::occi::OCCIINT,
                            sizeof(logicid_vec[0]), intSize);
        // for each column build the data array
        oracle::occi::Type type = oracle::occi::OCCIFLOAT;
        for (int i = 0; i < nParameters; i++) {
          b = data2write.begin();
          // loop on all logic ids
          c = 0;
          while (b != e) {
            std::vector<float> x = b->second;
            if (m_type[i] == "INT") {
              intArray[c] = (int)rint(x[i]);
            } else if ((m_type[i] == "FLOAT") || (m_type[i] == "NUMBER")) {
              floatArray[c] = x[i];
            } else {
              throw(std::runtime_error("ERROR: LMFDat::writeDB: unsupported type"));
            }
            c++;
            b++;
          }
          // copy data into a "permanent" buffer
          dvoid * buffer;
          type = oracle::occi::OCCIINT;
          ub2 *sizeArray = intSize;
          int size = sizeof(intArray[0]);
          if ((m_type[i] == "FLOAT") || (m_type[i] == "NUMBER")) {
            buffer = (dvoid *)malloc(sizeof(float)*nData);
            memcpy(buffer, floatArray, floatTotalSize);
            type = oracle::occi::OCCIFLOAT;
            sizeArray = floatSize;
            size = sizeof(floatArray[0]);
          } else {
            buffer = (dvoid *)malloc(sizeof(int)*nData);
            memcpy(buffer, intArray, intTotalSize);
          }
          bufPointers.push_back(buffer);
          if (m_debug) {
            for (int k = 0; ((k < nData) && (k < m_max)); k++) {
              cout << m_className << ": === Index=== " << k << endl;
              cout << m_className << ": RUN_IOV_ID = " << iovid_vec[k] << endl;
              cout << m_className << ": LOGIC_ID = " << logicid_vec[k] << endl;
              cout << m_className << ": FIELD " << i << ": " 
                   << ((float *)(buffer))[k] << endl;
            }
          }
          stmt->setDataBuffer(i + 3, buffer, type, size, sizeArray);
        }
        stmt->executeArrayUpdate(nData);
        delete [] intArray;
        delete [] floatArray;
        delete [] intSize;
        delete [] floatSize;
        delete [] logicid_vec;
        delete [] iovid_vec;
        std::list<dvoid *>::const_iterator bi = bufPointers.begin();
        std::list<dvoid *>::const_iterator be = bufPointers.end();
        while (bi != be) {
          free(*bi);
          bi++;
        }
        m_conn->commit();
        m_conn->terminateStatement(stmt);
        ret = nData;
      } catch (oracle::occi::SQLException &e) {
        debug();
        setMaxDataToDump(nData);
        // get the Foreign Key
        LMFRunIOV *runiov = (LMFRunIOV*)m_foreignKeys[foreignKeyName()];
        int iov_id = runiov->getID();
        std::cout << "==== This object refers to IOV " << iov_id << std::endl;
        dump();
        m_conn->rollback();
        throw(std::runtime_error(m_className + "::writeDB: " + 
                                 e.getMessage()));
      }
    } else {
      cout << m_className << "::writeDB: Cannot write because " << 
        m_Error << endl;
      dump();
    }
  }
  return ret;
}

void LMFDat::getKeyTypes() 
  throw(std::runtime_error)
{
  m_type.reserve(m_keys.size());
  for (unsigned int i = 0; i < m_keys.size(); i++) {
    m_type.push_back("");
  }
  // get the description of the table
  std::string sql = "";
  try {
    Statement *stmt = m_conn->createStatement();
    sql = "SELECT * FROM TABLE(CMS_ECAL_LASER_COND.LMF_TAB_COLS(:1, :2))";
    /*
    sql = "SELECT COLUMN_NAME, DATA_TYPE FROM " 
      "USER_TAB_COLS WHERE TABLE_NAME = '" + getTableName() + "' " 
      "AND COLUMN_NAME != '" + getIovIdFieldName() +  "' AND COLUMN_NAME != " 
      "'LOGIC_ID'";
    */
    stmt->setSQL(sql);
    stmt->setString(1, getTableName());
    stmt->setString(2, getIovIdFieldName());
    ResultSet *rset = stmt->executeQuery();
    while (rset->next() != 0) {
      std::string name = rset->getString(1);
      std::string t = rset->getString(2);
      m_type[m_keys[name]] = t;
    }
    m_conn->terminateStatement(stmt);
  } catch (oracle::occi::SQLException &e) {
    throw(std::runtime_error(m_className + "::getKeyTypes: " + e.getMessage() +
                        " [" + sql + "]"));
  }
}

bool LMFDat::check() {
  // check that everything has been correctly setup
  bool ret = true;
  m_Error = "";
  // first of all we need to check that the class name has been set
  if (m_className == "LMFUnique") {
    m_Error = "class name not set ";
    ret = false;
  }
  //then check that the table name has been set
  if (getTableName() == "") {
    m_Error += "table name not set ";
    ret = false;
  }
  // fill key types if not yet done
  if (m_type.size() != m_keys.size()) {
    getKeyTypes();
    if (m_type.size() != m_keys.size()) {
      m_Error += "key size does not correspond to table definition";
      ret = false;
    }
  }
  return ret;
}

/* unsafe methods */

std::vector<float> LMFDat::getData(int id) {
  std::vector<float> ret;
  if (m_data.find(id) != m_data.end()) {
    ret = m_data[id];
  }
  return ret;
}

std::vector<float> LMFDat::operator[](int id) {
  return getData(id);
}

std::vector<float> LMFDat::getData(const EcalLogicID &id) {
  return getData(id.getLogicID());
}

/* safe methods */

bool LMFDat::getData(int id, std::vector<float> &ret) {
  bool retval = false;
  if (m_data.find(id) != m_data.end()) {
    ret= m_data[id];
    retval = true;
  }
  return retval;
}

bool LMFDat::getData(const EcalLogicID &id, std::vector<float> &ret) {
  return getData(id.getLogicID(), ret);
}

/* all data */

std::map<int, std::vector<float> > LMFDat::getData() {
  return m_data;
}

/* unsafe */

float LMFDat::getData(int id, unsigned int k) {
  return m_data[id][k];
}

float LMFDat::getData(const EcalLogicID &id, unsigned int k) {
  return getData(id.getLogicID(), k);
}

float LMFDat::getData(const EcalLogicID &id, const std::string &key) {
  return getData(id.getLogicID(), m_keys[key]);
}

float LMFDat::getData(int id, const std::string &key) {
  return getData(id, m_keys[key]);
}

/* safe */

bool LMFDat::getData(int id, unsigned int k, float &ret) {
  bool retval = false;
  std::vector<float> v;
  retval = getData(id, v);
  if ((retval) && (v.size() > k)) {
    ret= v[k];
    retval = true;
  } else {
    retval = false;
  }
  return retval;
}

bool LMFDat::getData(const EcalLogicID &id, unsigned int k, float &ret) {
  return getData(id.getLogicID(), k, ret);
}

bool LMFDat::getData(int id, const std::string &key, float &ret) {
  bool retval = false;
  if (m_keys.find(key) != m_keys.end()) {
    retval = getData(id, m_keys[key], ret); 
  }
  return retval;
}

bool LMFDat::getData(const EcalLogicID &id, const std::string &key, float &ret)
{
  return getData(id.getLogicID(), key, ret);
}