RevisionDML.cc

Go to the documentation of this file.

#include "RecoLuminosity/LumiProducer/interface/RevisionDML.h"
#include "RelationalAccess/ISchema.h"
#include "RelationalAccess/ITable.h"
#include "RelationalAccess/ITableDataEditor.h"
#include "RelationalAccess/IQuery.h"
#include "RelationalAccess/ICursor.h"
#include "RelationalAccess/SchemaException.h"
#include "CoralBase/AttributeList.h"
#include "CoralBase/Attribute.h"
#include "CoralBase/AttributeSpecification.h"
#include "CoralBase/TimeStamp.h"
#include "RecoLuminosity/LumiProducer/interface/LumiNames.h"
#include "RecoLuminosity/LumiProducer/interface/idDealer.h"
#include "RecoLuminosity/LumiProducer/interface/Exception.h"
#include <algorithm>
unsigned long long lumi::RevisionDML::getEntryInBranchByName(coral::ISchema& schema,
                                                             const std::string& datatableName,
                                                             const std::string& entryname,
                                                             const std::string& branchname) {
  unsigned long long entry_id = 0;
  coral::IQuery* qHandle = schema.newQuery();
  qHandle->addToTableList(lumi::LumiNames::entryTableName(datatableName), "e");
  qHandle->addToTableList(lumi::LumiNames::revisionTableName(), "r");
  qHandle->addToOutputList("e.ENTRY_ID", "entry_id");

  coral::AttributeList qCondition;
  qCondition.extend("entryname", typeid(std::string));
  qCondition.extend("branchname", typeid(std::string));
  qCondition["entryname"].data<std::string>() = entryname;
  qCondition["branchname"].data<std::string>() = branchname;
  std::string qConditionStr("r.REVISION_ID=e.REVISION_ID and e.NAME=:entryname AND r.BRANCH_NAME=:branchname");

  coral::AttributeList qResult;
  qResult.extend("entry_id", typeid(unsigned long long));
  qHandle->defineOutput(qResult);
  qHandle->setCondition(qConditionStr, qCondition);
  coral::ICursor& cursor = qHandle->execute();
  while (cursor.next()) {
    entry_id = cursor.currentRow()["entry_id"].data<unsigned long long>();
  }
  delete qHandle;
  return entry_id;
}
void lumi::RevisionDML::bookNewEntry(coral::ISchema& schema,
                                     const std::string& datatableName,
                                     lumi::RevisionDML::Entry& entry) {
  lumi::idDealer idg(schema);
  const std::string entrytableName = lumi::LumiNames::entryTableName(datatableName);
  entry.revision_id = idg.generateNextIDForTable(lumi::LumiNames::revisionTableName());
  entry.data_id = idg.generateNextIDForTable(datatableName);
  entry.entry_id = idg.generateNextIDForTable(entrytableName);
}
void lumi::RevisionDML::bookNewRevision(coral::ISchema& schema,
                                        const std::string& datatableName,
                                        lumi::RevisionDML::Entry& revision) {
  lumi::idDealer idg(schema);
  revision.revision_id = idg.generateNextIDForTable(lumi::LumiNames::revisionTableName());
  revision.data_id = idg.generateNextIDForTable(datatableName);
}
void lumi::RevisionDML::addEntry(coral::ISchema& schema,
                                 const std::string& datatableName,
                                 const lumi::RevisionDML::Entry& entry,
                                 unsigned long long branchid,
                                 const std::string& branchname) {
  coral::AttributeList revdata;
  revdata.extend("REVISION_ID", typeid(unsigned long long));
  revdata.extend("BRANCH_ID", typeid(unsigned long long));
  revdata.extend("BRANCH_NAME", typeid(std::string));
  revdata.extend("CTIME", typeid(coral::TimeStamp));
  revdata["REVISION_ID"].data<unsigned long long>() = entry.revision_id;
  revdata["BRANCH_ID"].data<unsigned long long>() = branchid;
  revdata["BRANCH_NAME"].data<std::string>() = branchname;
  revdata["CTIME"].data<coral::TimeStamp>() = coral::TimeStamp::now();
  const std::string revTableName = lumi::LumiNames::revisionTableName();
  schema.tableHandle(revTableName).dataEditor().insertRow(revdata);

  coral::AttributeList entrydata;
  entrydata.extend("REVISION_ID", typeid(unsigned long long));
  entrydata.extend("ENTRY_ID", typeid(unsigned long long));
  entrydata.extend("NAME", typeid(std::string));
  entrydata["REVISION_ID"].data<unsigned long long>() = entry.revision_id;
  entrydata["ENTRY_ID"].data<unsigned long long>() = entry.entry_id;
  entrydata["NAME"].data<std::string>() = entry.entry_name;
  const std::string entryTableName = lumi::LumiNames::entryTableName(datatableName);
  schema.tableHandle(entryTableName).dataEditor().insertRow(entrydata);

  coral::AttributeList revmapdata;
  revmapdata.extend("REVISION_ID", typeid(unsigned long long));
  revmapdata.extend("DATA_ID", typeid(unsigned long long));

  revmapdata["REVISION_ID"].data<unsigned long long>() = entry.revision_id;
  revmapdata["DATA_ID"].data<unsigned long long>() = entry.data_id;

  const std::string revmapTableName = lumi::LumiNames::revmapTableName(datatableName);
  schema.tableHandle(revmapTableName).dataEditor().insertRow(revmapdata);
}
void lumi::RevisionDML::addRevision(coral::ISchema& schema,
                                    const std::string& datatableName,
                                    const lumi::RevisionDML::Entry& revision,
                                    unsigned long long branchid,
                                    std::string& branchname) {
  coral::AttributeList revdata;
  revdata.extend("REVISION_ID", typeid(unsigned long long));
  revdata.extend("BRANCH_ID", typeid(unsigned long long));
  revdata.extend("BRANCH_NAME", typeid(std::string));
  revdata.extend("CTIME", typeid(coral::TimeStamp));
  revdata["REVISION_ID"].data<unsigned long long>() = revision.revision_id;
  revdata["BRANCH_ID"].data<unsigned long long>() = branchid;
  revdata["BRANCH_NAME"].data<std::string>() = branchname;
  revdata["CTIME"].data<coral::TimeStamp>() = coral::TimeStamp::now();
  schema.tableHandle(lumi::LumiNames::revisionTableName()).dataEditor().insertRow(revdata);
  coral::AttributeList revmapdata;
  revmapdata.extend("REVISION_ID", typeid(unsigned long long));
  revmapdata.extend("DATA_ID", typeid(unsigned long long));
  revmapdata["REVISION_ID"].data<unsigned long long>() = revision.revision_id;
  revmapdata["DATA_ID"].data<unsigned long long>() = revision.data_id;
  const std::string revmapTableName = lumi::LumiNames::revmapTableName(datatableName);
  schema.tableHandle(revmapTableName).dataEditor().insertRow(revmapdata);
}
void lumi::RevisionDML::insertLumiRunData(coral::ISchema& schema, const lumi::RevisionDML::LumiEntry& lumientry) {
  coral::AttributeList lumirundata;
  lumirundata.extend("DATA_ID", typeid(unsigned long long));
  lumirundata.extend("ENTRY_ID", typeid(unsigned long long));
  lumirundata.extend("ENTRY_NAME", typeid(std::string));
  lumirundata.extend("RUNNUM", typeid(unsigned int));
  lumirundata.extend("SOURCE", typeid(std::string));
  lumirundata.extend("NOMINALEGEV", typeid(float));
  lumirundata.extend("NCOLLIDINGBUNCHES", typeid(unsigned int));
  lumirundata["DATA_ID"].data<unsigned long long>() = lumientry.data_id;
  lumirundata["ENTRY_ID"].data<unsigned long long>() = lumientry.entry_id;
  lumirundata["ENTRY_NAME"].data<std::string>() = lumientry.entry_name;
  lumirundata["RUNNUM"].data<unsigned int>() = lumientry.runnumber;
  lumirundata["SOURCE"].data<std::string>() = lumientry.source;
  lumirundata["NOMINALEGEV"].data<float>() = lumientry.bgev;
  lumirundata["NCOLLIDINGBUNCHES"].data<unsigned int>() = lumientry.ncollidingbunches;
  const std::string lumidataTableName = lumi::LumiNames::lumidataTableName();
  schema.tableHandle(lumidataTableName).dataEditor().insertRow(lumirundata);
}
void lumi::RevisionDML::insertTrgRunData(coral::ISchema& schema, const lumi::RevisionDML::TrgEntry& trgentry) {
  coral::AttributeList trgrundata;
  trgrundata.extend("DATA_ID", typeid(unsigned long long));
  trgrundata.extend("ENTRY_ID", typeid(unsigned long long));
  trgrundata.extend("ENTRY_NAME", typeid(std::string));
  trgrundata.extend("RUNNUM", typeid(unsigned int));
  trgrundata.extend("SOURCE", typeid(std::string));
  trgrundata.extend("BITZERONAME", typeid(std::string));
  trgrundata.extend("BITNAMECLOB", typeid(std::string));
  trgrundata["DATA_ID"].data<unsigned long long>() = trgentry.data_id;
  trgrundata["ENTRY_ID"].data<unsigned long long>() = trgentry.entry_id;
  trgrundata["ENTRY_NAME"].data<std::string>() = trgentry.entry_name;
  trgrundata["RUNNUM"].data<unsigned int>() = trgentry.runnumber;
  trgrundata["SOURCE"].data<std::string>() = trgentry.source;
  trgrundata["BITZERONAME"].data<std::string>() = trgentry.bitzeroname;
  trgrundata["BITNAMECLOB"].data<std::string>() = trgentry.bitnames;
  const std::string trgdataTableName = lumi::LumiNames::trgdataTableName();
  schema.tableHandle(trgdataTableName).dataEditor().insertRow(trgrundata);
}
void lumi::RevisionDML::insertHltRunData(coral::ISchema& schema, const lumi::RevisionDML::HltEntry& hltentry) {
  coral::AttributeList hltrundata;
  hltrundata.extend("DATA_ID", typeid(unsigned long long));
  hltrundata.extend("ENTRY_ID", typeid(unsigned long long));
  hltrundata.extend("ENTRY_NAME", typeid(std::string));
  hltrundata.extend("RUNNUM", typeid(unsigned int));
  hltrundata.extend("SOURCE", typeid(std::string));
  hltrundata.extend("NPATH", typeid(unsigned int));
  hltrundata.extend("PATHNAMECLOB", typeid(std::string));
  hltrundata["DATA_ID"].data<unsigned long long>() = hltentry.data_id;
  hltrundata["ENTRY_ID"].data<unsigned long long>() = hltentry.entry_id;
  hltrundata["ENTRY_NAME"].data<std::string>() = hltentry.entry_name;
  hltrundata["RUNNUM"].data<unsigned int>() = hltentry.runnumber;
  hltrundata["SOURCE"].data<std::string>() = hltentry.source;
  hltrundata["NPATH"].data<unsigned int>() = hltentry.npath;
  hltrundata["PATHNAMECLOB"].data<std::string>() = hltentry.pathnames;
  const std::string hltdataTableName = lumi::LumiNames::hltdataTableName();
  schema.tableHandle(hltdataTableName).dataEditor().insertRow(hltrundata);
}

unsigned long long lumi::RevisionDML::currentHFDataTagId(coral::ISchema& schema) {
  unsigned long long currentdatatagid = 0;
  std::vector<unsigned long long> alltagids;
  coral::IQuery* qHandle = schema.newQuery();
  qHandle->addToTableList(lumi::LumiNames::tagsTableName());
  qHandle->addToOutputList("TAGID");
  coral::AttributeList qResult;
  qResult.extend("TAGID", typeid(unsigned long long));
  qHandle->defineOutput(qResult);
  coral::ICursor& cursor = qHandle->execute();
  while (cursor.next()) {
    if (!cursor.currentRow()["TAGID"].isNull()) {
      alltagids.push_back(cursor.currentRow()["TAGID"].data<unsigned long long>());
    }
  }
  delete qHandle;
  if (!alltagids.empty()) {
    std::vector<unsigned long long>::iterator currentdatatagidIt = std::max_element(alltagids.begin(), alltagids.end());
    currentdatatagid = *currentdatatagidIt;
  }
  return currentdatatagid;
}

unsigned long long lumi::RevisionDML::HFDataTagIdByName(coral::ISchema& schema, const std::string& datatagname) {
  unsigned long long datatagid = 0;
  coral::IQuery* qHandle = schema.newQuery();
  qHandle->addToTableList(lumi::LumiNames::tagsTableName());
  const std::string conditionStr("TAGNAME=:tagname");
  coral::AttributeList condition;
  condition.extend("tagname", typeid(std::string));
  condition["tagname"].data<std::string>() = datatagname;
  qHandle->addToOutputList("TAGID");
  coral::AttributeList qResult;
  qResult.extend("TAGID", typeid(unsigned long long));
  qHandle->setCondition(conditionStr, condition);
  qHandle->defineOutput(qResult);
  coral::ICursor& cursor = qHandle->execute();
  while (cursor.next()) {
    if (!cursor.currentRow()["TAGID"].isNull()) {
      datatagid = cursor.currentRow()["TAGID"].data<unsigned long long>();
    }
  }
  delete qHandle;
  return datatagid;
}

unsigned long long lumi::RevisionDML::addRunToCurrentHFDataTag(coral::ISchema& schema,
                                                               unsigned int runnum,
                                                               unsigned long long lumiid,
                                                               unsigned long long trgid,
                                                               unsigned long long hltid,
                                                               const std::string& patchcomment) {
  unsigned long long currenttagid = currentHFDataTagId(schema);
  coral::AttributeList tagrundata;
  tagrundata.extend("TAGID", typeid(unsigned long long));
  tagrundata.extend("RUNNUM", typeid(unsigned int));
  tagrundata.extend("LUMIDATAID", typeid(unsigned long long));
  tagrundata.extend("TRGDATAID", typeid(unsigned long long));
  tagrundata.extend("HLTDATAID", typeid(unsigned long long));
  tagrundata.extend("CREATIONTIME", typeid(coral::TimeStamp));
  tagrundata.extend("COMMENT", typeid(std::string));
  tagrundata["TAGID"].data<unsigned long long>() = currenttagid;
  tagrundata["RUNNUM"].data<unsigned int>() = runnum;
  tagrundata["LUMIDATAID"].data<unsigned long long>() = lumiid;
  tagrundata["TRGDATAID"].data<unsigned long long>() = trgid;
  tagrundata["HLTDATAID"].data<unsigned long long>() = hltid;
  tagrundata["CREATIONTIME"].data<coral::TimeStamp>() = coral::TimeStamp::now();
  tagrundata["COMMENT"].data<std::string>() = patchcomment;
  const std::string tagrunTableName = lumi::LumiNames::tagRunsTableName();
  try {
    schema.tableHandle(lumi::LumiNames::tagRunsTableName()).dataEditor().insertRow(tagrundata);
  } catch (const coral::DuplicateEntryInUniqueKeyException& er) {
    throw lumi::duplicateRunInDataTagException("", "addRunToCurrentHFDataTag", "RevisionDML");
  }
  return currenttagid;
}

lumi::RevisionDML::DataID lumi::RevisionDML::dataIDForRun(coral::ISchema& schema,
                                                          unsigned int runnum,
                                                          unsigned long long tagid) {
  lumi::RevisionDML::DataID result;
  coral::IQuery* qHandle = schema.newQuery();
  qHandle->addToTableList(lumi::LumiNames::tagRunsTableName());
  qHandle->addToOutputList("LUMIDATAID");
  qHandle->addToOutputList("TRGDATAID");
  qHandle->addToOutputList("HLTDATAID");
  coral::AttributeList qResult;
  qResult.extend("LUMIDATAID", typeid(unsigned long long));
  qResult.extend("TRGDATAID", typeid(unsigned long long));
  qResult.extend("HLTDATAID", typeid(unsigned long long));
  qHandle->defineOutput(qResult);
  coral::AttributeList qCondition;
  qCondition.extend("tagid", typeid(unsigned long long));
  qCondition.extend("runnum", typeid(unsigned int));
  qCondition["tagid"].data<unsigned long long>() = tagid;
  qCondition["runnum"].data<unsigned int>() = runnum;
  std::string qConditionStr("TAGID<=:tagid AND RUNNUM=:runnum");
  qHandle->setCondition(qConditionStr, qCondition);
  coral::ICursor& cursor = qHandle->execute();
  unsigned long long minlumid = 0;
  unsigned long long mintrgid = 0;
  unsigned long long minhltid = 0;
  while (cursor.next()) {
    if (!cursor.currentRow()["LUMIDATAID"].isNull()) {
      unsigned long long lumiid = cursor.currentRow()["LUMIDATAID"].data<unsigned long long>();
      if (lumiid > minlumid) {
        result.lumi_id = lumiid;
      }
    }
    if (!cursor.currentRow()["TRGDATAID"].isNull()) {
      unsigned long long trgid = cursor.currentRow()["TRGDATAID"].data<unsigned long long>();
      if (trgid > mintrgid) {
        result.trg_id = trgid;
      }
    }
    if (!cursor.currentRow()["HLTDATAID"].isNull()) {
      unsigned long long hltid = cursor.currentRow()["HLTDATAID"].data<unsigned long long>();
      if (hltid > minhltid) {
        result.hlt_id = hltid;
      }
    }
  }
  delete qHandle;
  return result;
}