calibUtil::Metadata Class Reference

#include <Metadata.h>

List of all members.

Public Types

 RETOk = 0
 RETBadCnfFile = 1
 RETBadHost = 2
 RETNoConnect = 3
 RETWrongState = 4
 RETBadValue = 5
 RETMySQLError = 6
 RETNoSchemaMatch = 7
 LEVELProd = 1
 LEVELDev = 2
 LEVELTest = 4
 LEVELSuperseded = 8
enum  eRet {
  RETOk = 0, RETBadCnfFile = 1, RETBadHost = 2, RETNoConnect = 3,
  RETWrongState = 4, RETBadValue = 5, RETMySQLError = 6, RETNoSchemaMatch = 7
}
enum  eLevel { LEVELProd = 1, LEVELDev = 2, LEVELTest = 4, LEVELSuperseded = 8 }
 Used to form bit masks for dbs queries. More...

Public Member Functions

 Metadata (const std::string &host="bes3db2.ihep.ac.cn", const std::string &table="*", const std::string &dbName="calib")
 Constructor keeps track of table of interest.
 ~Metadata ()
eRet findBest (unsigned int *ser, const std::string &calibType, const std::string &sft_ver, const std::string &cal_ver, const std::string &cal_par, const std::string &rec_alg, const std::string &rec_par, const std::string &machine, const std::string &flavor="VANILLA")
eRet findSoonAfter (unsigned int *ser, const std::string &calibType, const std::string &sft_ver, const std::string &cal_ver, const std::string &cal_par, const std::string &rec_alg, const std::string &rec_par, const std::string &machine, const std::string &flavor="VANILLA")
eRet getInterval (unsigned int serialNo, facilities::Timestamp *&since, facilities::Timestamp *&till)
 Get validity interval for a particular calibration.
eRet getReadInfo (unsigned int serialNo, int *runFrm, int *runTo, std::string &dataFmt, std::string &dataIdent)
eRet getReadTOFInfo (unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
eRet getReadEMCInfo (unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
eRet getReadDedxInfo (unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
eRet getReadMDCInfo (unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
eRet getReadMUCInfo (unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
eRet getReadEsTimeInfo (unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
eRet getReadEstTofInfo (unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
eRet getReadMdcAlignInfo (unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
eRet getReadMdcDataConstInfo (unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
eRet getReadTofQElecInfo (unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
eRet getReadTofSimInfo (unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
eRet getReadDedxSimInfo (unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
int registerCalib (const std::string &inst, const std::string &flavor, const std::string &calib_type, const std::string &data_ident, const std::string &data_format, unsigned int &runfrm, unsigned int &runto, const std::string &input_desc, const std::string &notes, const std::string &proc_level, const std::string &locale, const std::string &fmt_version="", const std::string &completion="OK")
bool connectRead (eRet &err)
bool checkValues (const rdbModel::StringVector &cols, const rdbModel::StringVector &vals) const
bool checkNulls (const rdbModel::StringVector &cols) const
rdbModel::ConnectiongetReadConnection ()
rdbModel::RdbgetRdb ()
const std::stringgetTable ()
void disconnectRead ()
void disconnectWrite ()

Private Member Functions

unsigned adjustVend (int newSer)
bool fetchLevel (std::string &val, unsigned int *levelMask)
bool connectWrite (eRet &err)
eRet compareSchema (rdbModel::Connection *conn, const std::string &schema)
eRet doSelect (std::vector< rdbModel::Assertion::Operator * > &conditions, rdbModel::StringVector &orderBy, unsigned *&ser)
eRet fetchUser (std::string &user)
 Discover username and store in caller-supplied string.

Static Private Member Functions

static bool connect (rdbModel::Connection *conn, std::string &host, const std::string &user, const std::string &pw, eRet &err, const std::string &dbName)

Private Attributes

rdbModel::Connectionm_readCxt
rdbModel::Connectionm_writeCxt
rdbModel::Assertionm_findBest
rdbModel::Assertionm_findSoonest
std::string m_host
 Constant bit mask indicating all necessary fields have been set.
std::string m_table
std::string m_dbName
rdbModel::Managerm_man
rdbModel::Rdbm_rdb
IDatabaseSvcm_dbsvc
bool m_match


Detailed Description

Provide interface between calibration clients and the MySQL database for calibration metadata. Supported operations include writing a new record, looking for the serial number of a "best match" record (findBest), and a method for retrieving the information necessary to read the data set corresponding to a particular metadata record (getReadInfo). Writing a record is done in stages: open the record (openRecord), add certain fields (addValidInterval, addNotes, etc.), and finally to write the full record to the database (insertRecord).

The class contains definitions for several enumerated types, corresponding to possible entries for columns in a metadata record. Within the MySQL database the values are kept as strings. The enumerated types are provided to insulate clients from these details; enumerations are easier to document and to check for validity.

Definition at line 33 of file Metadata.h.


Member Enumeration Documentation

enum calibUtil::Metadata::eLevel

Used to form bit masks for dbs queries.

Enumerator:
LEVELProd 
LEVELDev 
LEVELTest 
LEVELSuperseded 

Definition at line 46 of file Metadata.h.

00046                 {
00047       LEVELProd = 1,
00048       LEVELDev  = 2,
00049       LEVELTest = 4,
00050       LEVELSuperseded = 8
00051     };

enum calibUtil::Metadata::eRet

Enumerator:
RETOk 
RETBadCnfFile 
RETBadHost 
RETNoConnect 
RETWrongState 
RETBadValue 
RETMySQLError 
RETNoSchemaMatch 

Definition at line 35 of file Metadata.h.

00035               {
00036       RETOk = 0,
00037       RETBadCnfFile = 1,
00038       RETBadHost = 2,
00039       RETNoConnect = 3,
00040       RETWrongState = 4,
00041       RETBadValue = 5,
00042       RETMySQLError = 6,
00043       RETNoSchemaMatch = 7
00044     };


Constructor & Destructor Documentation

calibUtil::Metadata::Metadata ( const std::string host = "bes3db2.ihep.ac.cn",
const std::string table = "*",
const std::string dbName = "calib" 
)

Constructor keeps track of table of interest.

Definition at line 39 of file Metadata.cxx.

References m_dbsvc, m_host, m_table, and deljobs::string.

00041                 : m_readCxt(0), m_writeCxt(0), //  m_row(""), m_rowStatus(0), 
00042                 m_host(host), m_table(table), m_dbName(dbName), m_man(0), m_rdb(0),
00043                 m_match(false) {
00044                         if (table.compare("*") == 0) m_table = std::string("$(MYSQL_METATABLE)");
00045                         if (host.compare("*") == 0) m_host = std::string("$(MYSQL_HOST)");
00046 
00047                         int nsub = facilities::Util::expandEnvVar(&m_table);
00048                         // If this doesn't work, use default
00049                         if (nsub < 0) m_table = std::string("metadata");
00050                         StatusCode sc=Gaudi::svcLocator()->service("DatabaseSvc", m_dbsvc, true);
00051                         if ( !sc.isSuccess() ) {
00052                                 std::cout <<"Metadata ERROR ::Could not retrieve the DataBaseSvc" << std::endl;;
00053                                 exit(1);
00054                         }
00055                 }

calibUtil::Metadata::~Metadata (  ) 

Definition at line 57 of file Metadata.cxx.

References disconnectRead(), disconnectWrite(), and m_man.

00057                             {
00058                 disconnectRead();
00059                 disconnectWrite();
00060                 if (m_man) delete m_man;
00061         }


Member Function Documentation

unsigned calibUtil::Metadata::adjustVend ( int  newSer  )  [private]

Definition at line 1034 of file Metadata.cxx.

References connectWrite(), showlog::err, rdbModel::FIELDTYPElit, rdbModel::FIELDTYPEold, facilities::Timestamp::getString(), RawFileTools::itoa(), m_table, m_writeCxt, rdbModel::OPTYPEand, rdbModel::OPTYPEequal, rdbModel::OPTYPEgreaterThan, rdbModel::OPTYPElessThan, rdbModel::Connection::select(), deljobs::string, rdbModel::Connection::update(), and boss::where().

Referenced by registerCalib().

01034                                         {
01035         using namespace rdbModel;
01036 
01037         StringVector getCols;
01038         StringVector orderBy;
01039 
01040         orderBy.clear();
01041         getCols.reserve(7);
01042 
01043         std::string serString;
01044         facilities::Util::itoa(newSer, serString);
01045 
01046         getCols.push_back("flavor");
01047         getCols.push_back("calib_type");
01048         getCols.push_back("completion");
01049 
01050         ResultHandle* results = 0;
01051         eRet err;
01052         Assertion* where = 0;
01053         try {
01054                 if (!m_writeCxt) {
01055                         if (!connectWrite(err)) return 0;
01056                 }
01057 
01058                 Assertion::Operator* serOp = 
01059                         new Assertion::Operator(OPTYPEequal, "ser_no", serString, 
01060                                         FIELDTYPEold, FIELDTYPElit);
01061                 //false, true);
01062 
01063                 where = new Assertion(serOp);
01064 
01065                 // Fetch information for new row: vstart, flavor, completion,
01066                 // proc_level, calib_type, flavor
01067                 results = m_writeCxt->select(m_table, getCols, orderBy, where);
01068                 // results = m_writeCxt->select("metadata_v0", getCols, orderBy, where);
01069                 delete where;
01070                 where = 0;
01071         }
01072         catch (RdbException ex) {
01073                 std::cout << ex.getMsg();
01074                 delete where;         // return heap memory
01075                 return 0;
01076         }
01077         if (!results) { // This is an error. Should be non-null even if no rows
01078                 std::cout << "MySQL failure in SELECT" << std::endl;
01079                 return 0;  // nothing to fix
01080         }
01081         if (results->getNRows() != 1) { // also a problem
01082                 std::cout << "Look-up of serial# " << serString << " failed"
01083                         << std::endl;
01084                 return 0;
01085         }
01086         std::vector<std::string> fields;
01087         results->getRow(fields);
01088         if (fields[2] != "OK") return 0;  // don't bother fixing in this case
01089 
01090         // Now do an update on rows satisfying
01091         // ((flavor="f") && (calib_type = "c") && (completion= "OK") && 
01092         // (instrument = "i") &&  (proc_level = "p") && 
01093         //  (vstart < "new-start" (vend > "new-vstart") );
01094         std::vector<Assertion::Operator *> conditions;
01095         conditions.reserve(7);
01096         for (unsigned ix = 0; ix < 5; ix++) {
01097                 conditions.push_back(new Assertion::Operator(OPTYPEequal, getCols[ix],
01098                                         fields[ix], 
01099                                         FIELDTYPEold, FIELDTYPElit));
01100                 // false, true));
01101         }
01102         conditions.push_back(new Assertion::Operator(OPTYPElessThan, "vstart",
01103                                 fields[5], 
01104                                 FIELDTYPEold, FIELDTYPElit));
01105         //false, true));
01106         conditions.push_back(new Assertion::Operator(OPTYPEgreaterThan, "vend",
01107                                 fields[5], 
01108                                 FIELDTYPEold, FIELDTYPElit));
01109         // false, true));
01110 
01111         Assertion::Operator* andOp = 
01112                 new Assertion::Operator(OPTYPEand, conditions);
01113         where = new Assertion(andOp);
01114 
01115         StringVector toUpdate;
01116         toUpdate.push_back("vend");
01117         StringVector newVal;
01118         newVal.push_back(fields[5]);
01119         // also update update_time. If we leave it to MySQL, won't be GMT
01120         facilities::Timestamp curTime;
01121         toUpdate.push_back("update_time");newVal.push_back(curTime.getString());
01122 
01123         unsigned nModified = m_writeCxt->update(m_table, toUpdate, newVal, where);
01124         delete where;
01125         return nModified;
01126 }

bool calibUtil::Metadata::checkNulls ( const rdbModel::StringVector cols  )  const

Definition at line 1016 of file Metadata.cxx.

References rdbModel::Table::getColumnByName(), rdbModel::Rdb::getTable(), m_rdb, and m_table.

Referenced by registerCalib().

01016                                                                 {
01017         unsigned nCol = cols.size();
01018         rdbModel::Table* table = m_rdb->getTable(m_table);
01019 
01020 
01021         for (unsigned iCol = 0; iCol < nCol; iCol++) {
01022                 rdbModel::Column* col = table->getColumnByName(cols[iCol]);
01023                 if (!col->nullAllowed()) {
01024                         std::cerr << "Column "
01025                                 << cols[iCol] << " in table " << m_table
01026                                 << " is not nullable" << std::endl;
01027                         return false;
01028                 }
01029         }
01030         return true;
01031 }

bool calibUtil::Metadata::checkValues ( const rdbModel::StringVector cols,
const rdbModel::StringVector vals 
) const

Definition at line 999 of file Metadata.cxx.

References rdbModel::Table::getColumnByName(), rdbModel::Rdb::getTable(), m_rdb, and m_table.

Referenced by registerCalib().

01000                                                         {
01001         unsigned nCol = cols.size();
01002         rdbModel::Table* table = m_rdb->getTable(m_table);
01003 
01004 
01005         for (unsigned iCol = 0; iCol < nCol; iCol++) {
01006                 rdbModel::Column* col = table->getColumnByName(cols[iCol]);
01007                 if (!col->okValue(vals[iCol])) {
01008                         std::cerr << "Value " << vals[iCol] << " not allowed for column "
01009                                 << cols[iCol] << " in table " << m_table << std::endl;
01010                         return false;
01011                 }
01012         }
01013         return true;
01014 }

Metadata::eRet calibUtil::Metadata::compareSchema ( rdbModel::Connection conn,
const std::string schema 
) [private]

Definition at line 955 of file Metadata.cxx.

References rdbModel::Manager::build(), rdbModel::Manager::getManager(), rdbModel::Manager::getRdb(), m_man, m_match, m_rdb, rdbModel::MATCHcompatible, rdbModel::MATCHequivalent, rdbModel::MATCHfail, rdbModel::MATCHnoConnection, rdbModel::Connection::matchSchema(), RETBadCnfFile, RETBadValue, RETNoConnect, RETNoSchemaMatch, RETOk, rdbModel::Manager::setBuilder(), and rdbModel::Manager::setInputSource().

Referenced by connectWrite().

00956                                          {
00957         using namespace rdbModel;
00958 
00959 
00960         if (m_man) { // already did this
00961                 return (m_match) ? RETOk : RETNoSchemaMatch;
00962         }
00963         m_man = rdbModel::Manager::getManager();
00964 
00965         m_man->setBuilder(new rdbModel::XercesBuilder);
00966         m_man->setInputSource(schema);
00967 
00968         // Maybe first check if file exists?  E.g., try opening for read
00969 
00970         // good errcode is 0
00971         int errcode = m_man->build();
00972 
00973         if (errcode) {
00974                 std::cerr << "Error in database description file " << schema 
00975                         << std::endl;
00976                 std::cerr << "Parse failed with error " << errcode << std::endl;
00977                 return RETBadCnfFile;
00978         }
00979         m_rdb = m_man->getRdb();
00980 
00981         rdbModel::MATCH match = conn->matchSchema(m_rdb, false);
00982 
00983         switch (match) {
00984                 case rdbModel::MATCHequivalent:
00985                 case rdbModel::MATCHcompatible:
00986                         m_match = true;
00987                         return RETOk;
00988                 case rdbModel::MATCHfail:
00989                         std::cout << "XML schema and MySQL database are NOT compatible" 
00990                                 << std::endl;
00991                         return RETBadCnfFile;
00992                 case rdbModel::MATCHnoConnection:
00993                         std::cout << "Connection failed while attempting match" << std::endl;
00994                         return RETNoConnect;
00995         }
00996         return RETBadValue;
00997 }

bool calibUtil::Metadata::connect ( rdbModel::Connection conn,
std::string host,
const std::string user,
const std::string pw,
eRet err,
const std::string dbName 
) [static, private]

Definition at line 85 of file Metadata.cxx.

References rdbModel::Connection::open(), RETBadHost, RETNoConnect, and RETOk.

Referenced by connectRead(), and connectWrite().

00088                                                   {
00089 
00090                 int nSub = facilities::Util::expandEnvVar(&host);
00091                 if (nSub < 0) {
00092                         err = RETBadHost;
00093                         return false;
00094                 }
00095 
00096                 bool connected = cxt->open(host, user, pw, dbName);
00097                 if (connected) {
00098                         err = RETOk;
00099                         return true;
00100                 }
00101                 else {
00102                         err = RETNoConnect;
00103                         return false;
00104                 }
00105         }

bool calibUtil::Metadata::connectRead ( eRet err  ) 

Definition at line 107 of file Metadata.cxx.

References connect(), m_dbName, m_host, m_readCxt, and deljobs::string.

Referenced by findBest(), findSoonAfter(), and getReadInfo().

00107                                             {
00108                 if (m_readCxt == 0) {
00109                         // for now use std::cout, std::cerr 
00110                         m_readCxt = new rdbModel::MysqlConnection();
00111                         //   bool ok = connect(m_readCxt, m_host, std::string("maqm"), 
00112                         //                      std::string("maqm_offline"),  err, m_dbName);
00113                         bool ok = connect(m_readCxt, m_host, std::string("guest"),
00114                                         std::string("guestpass"),  err, m_dbName);
00115                         if (!ok) {
00116                                 delete m_readCxt;
00117                                 m_readCxt = 0;
00118                         } /* else { // look for compatible schema
00119                                          std::string schema = 
00120                                          std::string("$(RDBMODELROOT)/xml/")+ m_dbName + ".xml"; 
00121                                          err = compareSchema(m_readCxt, schema);
00122                                          }*/
00123                         return ok;
00124                 }
00125 
00126                 else return true;
00127         }

bool calibUtil::Metadata::connectWrite ( eRet err  )  [private]

Definition at line 129 of file Metadata.cxx.

References compareSchema(), connect(), m_dbName, m_host, m_readCxt, m_writeCxt, and deljobs::string.

Referenced by adjustVend(), and registerCalib().

00129                                              {
00130                 if (m_writeCxt == 0) {
00131                         m_writeCxt = new rdbModel::MysqlConnection();
00132                         bool ok;
00133                         if (m_dbName == std::string("calib_test") ) {
00134                                 ok = connect(m_writeCxt, m_host, std::string("calib_tester"), 
00135                                                 std::string("udine"), err, m_dbName);
00136                         }
00137                         else { 
00138                                 ok = connect(m_writeCxt, m_host, std::string("calibrator"), 
00139                                                 std::string("calibrator"), err, m_dbName);
00140                         }
00141                         if (!ok) {
00142                                 delete m_readCxt;
00143                                 m_readCxt = 0;
00144                         }     else { // look for compatible schema
00145                                 std::string schema = 
00146                                         std::string("$(RDBMODELROOT)/xml/")+ m_dbName + ".xml"; 
00147                                 err = compareSchema(m_writeCxt, schema);
00148                         }
00149 
00150                         return ok;
00151                 }
00152                 else return true;
00153         }

void calibUtil::Metadata::disconnectRead (  ) 

Definition at line 155 of file Metadata.cxx.

References rdbModel::Connection::close(), and m_readCxt.

Referenced by ~Metadata().

00155                                       {
00156                 if (m_readCxt) {
00157                         m_readCxt->close();
00158                         delete m_readCxt;
00159                         m_readCxt = 0;
00160                 }
00161         }

void calibUtil::Metadata::disconnectWrite (  ) 

Definition at line 163 of file Metadata.cxx.

References rdbModel::Connection::close(), and m_writeCxt.

Referenced by ~Metadata().

00163                                        {
00164                 if (m_writeCxt) {
00165                         m_writeCxt->close();
00166                         delete m_writeCxt;
00167                         m_writeCxt = 0;
00168                 }
00169         }

Metadata::eRet calibUtil::Metadata::doSelect ( std::vector< rdbModel::Assertion::Operator * > &  conditions,
rdbModel::StringVector orderBy,
unsigned *&  ser 
) [private]

Definition at line 810 of file Metadata.cxx.

References m_readCxt, m_table, rdbModel::OPTYPEand, RETMySQLError, RETOk, and rdbModel::Connection::select().

Referenced by findBest(), and findSoonAfter().

00812                                 {
00813         using namespace rdbModel;
00814         *ser = 0;
00815 
00816         StringVector colNames(1);
00817         colNames[0] = "ser_no"; 
00818 
00819         // make the combined operator
00820         Assertion::Operator andOp(OPTYPEand, conditions, true);
00821 
00822         //Following creates an assertion such that creator (us) continues
00823         // to own the associated operator.
00824         Assertion whereClause(&andOp, 0, true);
00825         ResultHandle* results = 0;
00826 
00827         if(results){
00828                 delete results;
00829         }
00830 
00831         try {               // make the query
00832                 results = m_readCxt->select(m_table, colNames, orderBy, &whereClause);
00833 
00834         }
00835         catch (RdbException ex) {
00836                 std::cout << ex.getMsg();
00837         }
00838 
00839         if (!results) {   // Error. Should have ResultHandle even if 0 rows.
00840                 std::cout<<"no results"<<std::endl;
00841                 return RETMySQLError;
00842         }
00843 
00844 
00845 
00846         std::cout<<"There are results"<<std::endl;
00847         // handle result.  
00848         if (results->getNRows() == 0) {
00849                 conditions.pop_back(); 
00850                 std::cout<<"no results"<<std::endl; 
00851         }
00852         else{          
00853                 std::vector<std::string> fields;
00854                 results->getRow(fields);
00855 
00856                 if(results){
00857                         delete results;
00858                 }
00859                 *ser = facilities::Util::stringToInt(fields[0]);
00860                 return RETOk;
00861         }
00862 
00863 }

bool calibUtil::Metadata::fetchLevel ( std::string val,
unsigned int *  levelMask 
) [private]

Metadata::eRet calibUtil::Metadata::fetchUser ( std::string user  )  [private]

Discover username and store in caller-supplied string.

Definition at line 64 of file Metadata.cxx.

References RETBadValue, RETOk, and deljobs::string.

Referenced by registerCalib().

00064                                                         {
00065                 // WARNING: Windows and Linux/Solaris use different standard variables
00066                 // for login name.  The test used below isn't quite right
00067                 // since one could conceivably compile with gcc on cygwin/Windows.
00068 #ifdef    __GNUG__ 
00069                 user = std::string("$(USER)");
00070 #else
00071                 user = std::string("$(USERNAME)");
00072 #endif
00073 
00074                 int nsub = facilities::Util::expandEnvVar(&user);
00075                 if (nsub == 1) {
00076                         return RETOk;
00077                 }
00078                 else {
00079                         user = std::string("");
00080                         return RETBadValue;
00081                 }
00082         }

Metadata::eRet calibUtil::Metadata::findBest ( unsigned int *  ser,
const std::string calibType,
const std::string sft_ver,
const std::string cal_ver,
const std::string cal_par,
const std::string rec_alg,
const std::string rec_par,
const std::string machine,
const std::string flavor = "VANILLA" 
)

Return serial number for calibration which is best match to criteria, using strings for calibType and instrument arguments. This method may be useful for development when a particular instrument or calibration type is not officially supported.

Parameters:
ser serial number of best match as integer or zero if no matches (output)
calibType type of data, must match
timestamp must be within validity interval; closer to center is better
levelMask acceptable levels ("production" better than "dev" better than "test" better than "superseded")
instrument e.g. LAT, EM, CU,...
flavor optionally specify non-standard calibration flavor
Returns:
status. Should be RETOk.
If there are multiple calibrations which are not distinguished by the above, pick the one most recently written.

Definition at line 243 of file Metadata.cxx.

References connectRead(), doSelect(), rdbModel::FIELDTYPElit, rdbModel::FIELDTYPEold, RawFileTools::itoa(), m_readCxt, rdbModel::OPTYPEequal, rdbModel::OPTYPEgreaterOrEqual, rdbModel::OPTYPElessOrEqual, RETOk, and deljobs::string.

00252         {
00253                 using namespace rdbModel;
00254 
00255                 eRet ret;
00256                 *ser = 0;
00257                 if (!m_readCxt) {
00258                         connectRead(ret);
00259                         if (ret != RETOk) return ret;
00260                 }
00261 
00262                 // Sort rows by timestamp. Would like most recent first
00263                 StringVector orderBy;
00264 
00265                 std::vector<Assertion::Operator *> conditions;
00266                 conditions.reserve(8);
00267                 Assertion::Operator completeOp(OPTYPEequal, "status", "OK",
00268                                 FIELDTYPEold, FIELDTYPElit);
00269                 //                               false, true);
00270 
00271                 Assertion::Operator calibTypeOp(OPTYPEequal, "calib_type", calibType,
00272                                 FIELDTYPEold, FIELDTYPElit);
00273                 //                                false, true);
00274                 //    Assertion::Operator flavorOp(OPTYPEequal, "flavor", flavor,
00275                 //                                 FIELDTYPEold, FIELDTYPElit);
00276                 //  false, true);
00277                 Assertion::Operator sftverOp(OPTYPEequal, "SftVer",SftVer,
00278                                 FIELDTYPEold, FIELDTYPElit);
00279                 Assertion::Operator calverOp(OPTYPEequal, "cal_ver",cal_ver,
00280                                 FIELDTYPEold, FIELDTYPElit);
00281                 Assertion::Operator calparOp(OPTYPEequal, "cal_par",cal_par,
00282                                 FIELDTYPEold, FIELDTYPElit);
00283                 Assertion::Operator recalgOp(OPTYPEequal, "rec_alg",rec_alg,
00284                                 FIELDTYPEold, FIELDTYPElit);
00285                 Assertion::Operator recparOp(OPTYPEequal, "rec_par",rec_par,
00286                                 FIELDTYPEold, FIELDTYPElit);
00287                 Assertion::Operator machineOp(OPTYPEequal, "machine",machine,
00288                                 FIELDTYPEold, FIELDTYPElit);
00289                 int run=10005;
00290                 std::string s_run;
00291                 facilities::Util::itoa(run,s_run);     
00292                 Assertion::Operator runfrmOp(OPTYPElessOrEqual,"RunFrom",s_run,
00293                                 FIELDTYPEold, FIELDTYPElit);
00294 
00295                 Assertion::Operator runtoOp(OPTYPEgreaterOrEqual,"RunTo",s_run,
00296                                 FIELDTYPEold, FIELDTYPElit);
00297 
00298                 conditions.push_back(&completeOp);
00299                 conditions.push_back(&calibTypeOp);
00300                 //    conditions.push_back(&flavorOp);
00301                 conditions.push_back(&sftverOp);
00302                 conditions.push_back(&calverOp);
00303                 conditions.push_back(&calparOp);
00304                 conditions.push_back(&recalgOp);
00305                 conditions.push_back(&recparOp);
00306                 conditions.push_back(&machineOp);
00307                 conditions.push_back(&runfrmOp);
00308                 conditions.push_back(&runtoOp);
00309                 // Finally, set a value for PROC_LEVEL and make the query (ies)
00310                 return doSelect(conditions, orderBy, ser);
00311         }

Metadata::eRet calibUtil::Metadata::findSoonAfter ( unsigned int *  ser,
const std::string calibType,
const std::string sft_ver,
const std::string cal_ver,
const std::string cal_par,
const std::string rec_alg,
const std::string rec_par,
const std::string machine,
const std::string flavor = "VANILLA" 
)

Similar to findBest above, but here caller constrains the update_time of the calibration by specifying an earliest and (optional) latest time for it. The serial number of the calibration meeting all other conditions, and with the earliest update_time, will be returned.

Parameters:
ser serial number of best match as integer or zero if no matches (output)
calibType type of data, must match
update_start ptr to time; early bound for update_time
update_end ptr to late bound for update_time (may be 0)
levelMask acceptable levels ("production" better than "dev" better than "test" better than "superseded")
instrument e.g. LAT, EM, CU,...
flavor optionally specify non-standard calibration flavor
Returns:
status. Should be RETOk.

Definition at line 172 of file Metadata.cxx.

References connectRead(), doSelect(), rdbModel::FIELDTYPElit, rdbModel::FIELDTYPEold, RawFileTools::itoa(), m_readCxt, rdbModel::OPTYPEequal, rdbModel::OPTYPEgreaterOrEqual, rdbModel::OPTYPElessOrEqual, RETOk, and deljobs::string.

00180                                                          {
00181                         using namespace rdbModel;
00182 
00183                         eRet ret;
00184                         *ser = 0;
00185                         if (!m_readCxt) {
00186                                 connectRead(ret);
00187                                 if (ret != RETOk) return ret;
00188                         }
00189 
00190                         StringVector orderBy;
00191 
00192                         std::vector<Assertion::Operator *> conditions;
00193                         conditions.reserve(8);
00194 
00195                         Assertion::Operator completeOp(OPTYPEequal, "status", "OK",
00196                                         FIELDTYPEold, FIELDTYPElit);
00197                         //                               false, true);
00198                         Assertion::Operator calibTypeOp(OPTYPEequal, "calib_type", calibType,
00199                                         FIELDTYPEold, FIELDTYPElit);
00200                         //                                false, true);
00201                         // Assertion::Operator flavorOp(OPTYPEequal, "flavor", flavor, 
00202                         //                              FIELDTYPEold, FIELDTYPElit);
00203                         //false, true);
00204                         Assertion::Operator sftverOp(OPTYPEequal, "SftVer",SftVer,
00205                                         FIELDTYPEold, FIELDTYPElit);
00206                         Assertion::Operator calverOp(OPTYPEequal, "cal_ver",cal_ver,
00207                                         FIELDTYPEold, FIELDTYPElit);
00208                         Assertion::Operator calparOp(OPTYPEequal, "cal_par",cal_par,
00209                                         FIELDTYPEold, FIELDTYPElit);
00210                         Assertion::Operator recalgOp(OPTYPEequal, "rec_alg",rec_alg,
00211                                         FIELDTYPEold, FIELDTYPElit);
00212                         Assertion::Operator recparOp(OPTYPEequal, "rec_par",rec_par,
00213                                         FIELDTYPEold, FIELDTYPElit);
00214                         Assertion::Operator machineOp(OPTYPEequal, "machine",machine,
00215                                         FIELDTYPEold, FIELDTYPElit);
00216 
00217                         int run=10005;
00218                         std::string s_run;
00219                         std::cout<<"run no is::"<<s_run<<std::endl;
00220                         facilities::Util::itoa(run,s_run);
00221                         Assertion::Operator runfrmOp(OPTYPElessOrEqual,"RunFrom",s_run,
00222                                         FIELDTYPEold, FIELDTYPElit);
00223 
00224                         Assertion::Operator runtoOp(OPTYPEgreaterOrEqual,"RunTo",s_run,
00225                                         FIELDTYPEold, FIELDTYPElit);
00226 
00227                         conditions.push_back(&completeOp);
00228                         conditions.push_back(&calibTypeOp);
00229                         //  conditions.push_back(&flavorOp);
00230                         conditions.push_back(&sftverOp);
00231                         conditions.push_back(&calverOp);
00232                         conditions.push_back(&calparOp);
00233                         conditions.push_back(&recalgOp);
00234                         conditions.push_back(&recparOp);
00235                         conditions.push_back(&machineOp);
00236                         conditions.push_back(&runfrmOp);
00237                         conditions.push_back(&runtoOp);
00238                         ret = doSelect(conditions, orderBy, ser);
00239 
00240                         return ret;
00241                 }

eRet calibUtil::Metadata::getInterval ( unsigned int  serialNo,
facilities::Timestamp *&  since,
facilities::Timestamp *&  till 
)

Get validity interval for a particular calibration.

rdbModel::Rdb* calibUtil::Metadata::getRdb (  )  [inline]

Definition at line 285 of file Metadata.h.

References m_rdb.

00285 {return m_rdb;}

rdbModel::Connection* calibUtil::Metadata::getReadConnection (  )  [inline]

Definition at line 282 of file Metadata.h.

References m_readCxt.

00282 {return m_readCxt;}

Metadata::eRet calibUtil::Metadata::getReadDedxInfo ( unsigned int  serialNo,
int *  runFrm,
int *  runTo,
std::string calParVer,
DatabaseRecordVector res,
int  runNo,
std::string sftver 
)

Definition at line 516 of file Metadata.cxx.

References m_dbsvc, IDatabaseSvc::query(), RETMySQLError, RETOk, and SftVer.

Referenced by CalibMySQLCnvSvc::createCalib(), and CalibMySQLCnvSvc::updateCalib().

00522                                    {
00523         using namespace rdbModel;
00524         eRet ret;
00525         char stmt1[400];
00526         int run_No =runNo;
00527         if(sftver=="default")
00528                 sftver = getenv("BES_RELEASE");
00529         const char* SftVer = sftver.c_str();
00530 
00531         if(calParVer!="default"){
00532                 const char* calpar = calParVer.c_str();
00533                 sprintf(stmt1,"select  DriftDist,EntranceAng,MeanGain,GasGain,LayerGain,Resolution,WireGain,ZDep,RunGain,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from DedxCalConst where  SftVer = '%s' and RunFrom <= %d and RunTo >= %d and CalParVer = %s",SftVer,run_No,run_No,calpar);
00534 
00535         }
00536         if(calParVer=="default"){
00537                 // sprintf(stmt1,"select  DriftDist,EntranceAng,MeanGain,GasGain,LayerGain,Resolution,WireGain,ZDep,RunGain,RunFrom,RunTo,max(CalParVer),FileName from DedxCalConst where  SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by CalParVer",SftVer,run_No,run_No);
00538                 sprintf(stmt1,"select  DriftDist,EntranceAng,MeanGain,GasGain,LayerGain,Resolution,WireGain,ZDep,RunGain,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from DedxCalConst where  SftVer = '%s' and RunFrom <= %d and RunTo >= %d order by CalParVer desc",SftVer,run_No,run_No);
00539         }
00540 
00541         int row_no = m_dbsvc->query("offlinedb", stmt1, res);
00542         if(row_no<1){
00543                 std::cout<<"ERROR:error searching Dedx calibration Data in the database with: "<<stmt1<<std::endl;
00544                 return RETMySQLError;
00545         }
00546         return RETOk;
00547 }

Metadata::eRet calibUtil::Metadata::getReadDedxSimInfo ( unsigned int  serialNo,
int *  runFrm,
int *  runTo,
std::string calParVer,
DatabaseRecordVector res,
int  runNo,
std::string sftver 
)

Definition at line 652 of file Metadata.cxx.

References m_dbsvc, IDatabaseSvc::query(), RETMySQLError, RETOk, and SftVer.

Referenced by CalibMySQLCnvSvc::createCalib(), and CalibMySQLCnvSvc::updateCalib().

00658                                    {
00659         using namespace rdbModel;
00660         eRet ret;
00661         char stmt1[200];
00662         int run_No =runNo;
00663         if(sftver=="default")
00664                 sftver = getenv("BES_RELEASE");
00665         const char* SftVer = sftver.c_str();
00666 
00667         if(calParVer!="default"){
00668                 const char* calpar = calParVer.c_str();
00669                 sprintf(stmt1,"select TH1F_Col,bin,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from DedxSim where SftVer = '%s' and RunFrom <= %d and RunTo >= %d and CalParVer = %s",SftVer,run_No,run_No,calpar);
00670         }
00671         if(calParVer=="default"){
00672                 sprintf(stmt1,"select  TH1F_Col,bin,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from DedxSim where SftVer = '%s' and RunFrom <= %d and RunTo >= %d order by CalParVer desc",SftVer,run_No,run_No);
00673         }
00674 
00675         int row_no = m_dbsvc->query("offlinedb", stmt1, res);
00676         if(row_no<1){
00677                 std::cout<<"ERROR:error searching DedxSim calibration Data in the database with: "<<stmt1<<std::endl;
00678                 return RETMySQLError;
00679         }
00680         return RETOk;
00681 }

Metadata::eRet calibUtil::Metadata::getReadEMCInfo ( unsigned int  serialNo,
int *  runFrm,
int *  runTo,
std::string calParVer,
DatabaseRecordVector res,
int  runNo,
std::string sftver 
)

Definition at line 482 of file Metadata.cxx.

References m_dbsvc, IDatabaseSvc::query(), RETMySQLError, RETOk, and SftVer.

Referenced by CalibMySQLCnvSvc::createCalib(), and CalibMySQLCnvSvc::updateCalib().

00488                                    {
00489         using namespace rdbModel;
00490         eRet ret;
00491         char stmt1[300];
00492         int run_No =runNo;
00493         if(sftver=="default")
00494                 sftver = getenv("BES_RELEASE");
00495         const char* SftVer = sftver.c_str();
00496 
00497         if(calParVer!="default"){ 
00498                 const char* calpar = calParVer.c_str();
00499                 sprintf(stmt1,"select DigiCalibConst,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from EmcCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d and CalParVer = %s",SftVer,run_No,run_No,calpar);
00500         }
00501 
00502         if(calParVer=="default"){
00503                 //sprintf(stmt1,"select DigiCalibConst,RunFrom,RunTo,max(CalParVer),FileName from EmcCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by CalParVer",SftVer,run_No,run_No);
00504                 sprintf(stmt1,"select DigiCalibConst,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from EmcCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d order by CalParVer desc",SftVer,run_No,run_No);
00505         } 
00506 
00507         int row_no = m_dbsvc->query("offlinedb", stmt1, res);
00508         if(row_no<1){
00509                 std::cout<<"ERROR:error searching EMC calibration Data in the database with: "<<stmt1<<std::endl;
00510                 return RETMySQLError;
00511         }
00512         return RETOk;
00513 }

Metadata::eRet calibUtil::Metadata::getReadEsTimeInfo ( unsigned int  serialNo,
int *  runFrm,
int *  runTo,
std::string calParVer,
DatabaseRecordVector res,
int  runNo,
std::string sftver 
)

Definition at line 550 of file Metadata.cxx.

References m_dbsvc, IDatabaseSvc::query(), RETMySQLError, RETOk, and SftVer.

Referenced by CalibMySQLCnvSvc::createCalib(), and CalibMySQLCnvSvc::updateCalib().

00556                                    {   
00557         using namespace rdbModel;   
00558         eRet ret;   
00559         char stmt1[400];   
00560         int run_No =runNo;   
00561         if(sftver=="default")
00562                 sftver = getenv("BES_RELEASE");
00563         const char* SftVer = sftver.c_str();
00564 
00565         if(calParVer!="default"){   
00566                 const char* calpar = calParVer.c_str();   
00567                 sprintf(stmt1,"select EsTimeH2,EsTimeH9,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from EsTimeCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d and CalParVer = %s",SftVer,run_No,run_No,calpar);   
00568         }   
00569 
00570         if(calParVer=="default"){   
00571                 sprintf(stmt1,"select EsTimeH2,EsTimeH9,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from EsTimeCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d order by CalParVer desc",SftVer,run_No,run_No);   
00572         }   
00573         int row_no = m_dbsvc->query("offlinedb", stmt1, res);
00574         if(row_no<1){
00575                 std::cout<<"ERROR:error searching EsTime calibration Data in the database with: "<<stmt1<<std::endl;
00576                 return RETMySQLError;
00577         }
00578 
00579         return RETOk;   
00580 } 

Metadata::eRet calibUtil::Metadata::getReadEstTofInfo ( unsigned int  serialNo,
int *  runFrm,
int *  runTo,
std::string calParVer,
DatabaseRecordVector res,
int  runNo,
std::string sftver 
)

Definition at line 584 of file Metadata.cxx.

References m_dbsvc, IDatabaseSvc::query(), RETMySQLError, RETOk, and SftVer.

Referenced by CalibMySQLCnvSvc::createCalib(), and CalibMySQLCnvSvc::updateCalib().

00590                                    {
00591         using namespace rdbModel;
00592         eRet ret;
00593         char stmt1[200];
00594         int run_No =runNo;
00595         if(sftver=="default")
00596                 sftver = getenv("BES_RELEASE");
00597         const char* SftVer = sftver.c_str();
00598 
00599         if(calParVer!="default"){
00600                 const char* calpar = calParVer.c_str();
00601                 sprintf(stmt1,"select BarTofPar,EndTofPar,TofConPar,BarTof,EtfTofPar,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from EstTofCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d and CalParVer = %s",SftVer,run_No,run_No,calpar);
00602         }
00603         if(calParVer=="default"){
00604                 //  sprintf(stmt1,"select BarTofPar,EndTofPar,TofConPar,BarTof,RunFrom,RunTo,max(CalParVer),FileName from EstTofCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by CalParVer",SftVer,run_No,run_No);
00605                 sprintf(stmt1,"select BarTofPar,EndTofPar,TofConPar,BarTof,EtfTofPar,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from EstTofCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d order by CalParVer desc",SftVer,run_No,run_No);
00606         }
00607 
00608         int row_no = m_dbsvc->query("offlinedb", stmt1, res);
00609         if(row_no<1){
00610                 std::cout<<"ERROR:error searching EstTOF calibration Data in the database with: "<<stmt1<<std::endl;
00611                 return RETMySQLError;
00612         }
00613         return RETOk;
00614 }

Metadata::eRet calibUtil::Metadata::getReadInfo ( unsigned int  serialNo,
int *  runFrm,
int *  runTo,
std::string dataFmt,
std::string dataIdent 
)

Given a calibration serial number, return information needed for caller to read in the data.

Parameters:
serialNo [input]
dataFormat 
fmtVersion 
filename 
Returns:
true if serialNo exists in dbs and "filename" has non-null value; else false.

Definition at line 314 of file Metadata.cxx.

References connectRead(), rdbModel::FIELDTYPElit, rdbModel::FIELDTYPEold, RawFileTools::itoa(), m_readCxt, m_table, rdbModel::OPTYPEequal, RETBadValue, RETMySQLError, RETOk, rdbModel::Connection::select(), and deljobs::string.

00318                                              {
00319                 using namespace rdbModel;
00320                 eRet ret;
00321                 if (!m_readCxt) {
00322                         connectRead(ret);
00323                         if (ret != RETOk) {
00324                                 return ret;
00325                         }
00326                 }
00327                 StringVector colNames(4);
00328                 colNames[0] = "data_fmt";
00329                 colNames[1] = "data_ident";
00330                 colNames[2] = "RunFrom";
00331                 colNames[3] = "RunTo";
00332 
00333                 std::string serNoVal;
00334                 facilities::Util::itoa(serialNo, serNoVal);
00335                 Assertion::Operator* serOp = 
00336                         new Assertion::Operator(OPTYPEequal, "ser_no", serNoVal, 
00337                                         FIELDTYPEold, FIELDTYPElit);
00338                 //false, true);
00339                 Assertion whereClause(serOp);
00340                 StringVector orderBy;
00341                 orderBy.clear();
00342 
00343                 // make the query
00344                 ResultHandle* results = 0;
00345                 try {
00346 
00347                         results = m_readCxt->select(m_table, colNames, orderBy, &whereClause);
00348 
00349                 }
00350                 catch (RdbException ex) {
00351                         std::cout << ex.getMsg();
00352                         return RETMySQLError;
00353                 }
00354 
00355                 if (!results) return RETMySQLError;
00356                 if (!results->getNRows() ) return RETBadValue;
00357 
00358                 std::vector<std::string> fields;
00359                 std::cout<<"test id \\"<<std::endl;
00360                 results->getRow(fields);
00361                 dataFmt = fields[0];
00362                 filename = fields[1];
00363                 std::string runfrm,runto;
00364                 runfrm=fields[2];
00365                 runto=fields[3];
00366                 *runFrm=facilities::Util::atoi(runfrm);
00367                 *runTo=facilities::Util::atoi(runto);
00368                 delete results;
00369                 //runFrm=fields[2];
00370                 //runTo=fields[3];
00371                 // std::cout<<"runfrm is:"<<runFrm<<"runto is:"<<runTo<<std::endl;
00372                 if ((dataFmt == "") || (filename == "")) return RETBadValue;
00373                 return RETOk;
00374         }

Metadata::eRet calibUtil::Metadata::getReadMdcAlignInfo ( unsigned int  serialNo,
int *  runFrm,
int *  runTo,
std::string calParVer,
DatabaseRecordVector res,
int  runNo,
std::string sftver 
)

Definition at line 685 of file Metadata.cxx.

References m_dbsvc, IDatabaseSvc::query(), RETMySQLError, RETOk, and SftVer.

Referenced by CalibMySQLCnvSvc::createCalib(), and CalibMySQLCnvSvc::updateCalib().

00691                                    {
00692         using namespace rdbModel;
00693         eRet ret;
00694         char stmt1[200];
00695         int run_No =runNo;
00696         if(sftver=="default")
00697                 sftver = getenv("BES_RELEASE");
00698         const char* SftVer = sftver.c_str();
00699 
00700         if(calParVer!="default"){
00701                 const char* calpar = calParVer.c_str();
00702                 sprintf(stmt1,"select AlignEndPlate,WirePos,WireTension,RunFrom,RunTo,MdcAlignVer,AlignEPFileName,Status,SftVer from MdcAlignment where SftVer = '%s' and RunFrom <= %d and RunTo >= %d and MdcAlignVer = %s",SftVer,run_No,run_No,calpar);
00703         }
00704         if(calParVer=="default"){
00705                 //     sprintf(stmt1,"select AlignEndPlate,WirePos,WireTension,RunFrom,RunTo,max(MdcAlignVer),AlignEPFileName from MdcAlignment where SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by MdcAlignVer",SftVer,run_No,run_No);
00706                 sprintf(stmt1,"select AlignEndPlate,WirePos,WireTension,RunFrom,RunTo,MdcAlignVer,AlignEPFileName,Status,SftVer from MdcAlignment where SftVer = '%s' and RunFrom <= %d and RunTo >= %d order by MdcAlignVer desc",SftVer,run_No,run_No);
00707         }
00708 
00709         int row_no = m_dbsvc->query("offlinedb", stmt1, res);
00710         if(row_no<1){
00711                 std::cout<<"ERROR:error searching MdcAlignment calibration Data in the database with: "<<stmt1<<std::endl;
00712                 return RETMySQLError;
00713         }
00714 
00715         return RETOk;
00716 }

Metadata::eRet calibUtil::Metadata::getReadMdcDataConstInfo ( unsigned int  serialNo,
int *  runFrm,
int *  runTo,
std::string calParVer,
DatabaseRecordVector res,
int  runNo,
std::string sftver 
)

Definition at line 718 of file Metadata.cxx.

References m_dbsvc, IDatabaseSvc::query(), RETMySQLError, RETOk, and SftVer.

Referenced by CalibMySQLCnvSvc::createCalib(), and CalibMySQLCnvSvc::updateCalib().

00724                                    {
00725         using namespace rdbModel;
00726         eRet ret;
00727         char stmt1[200];
00728         int run_No =runNo;
00729         if(sftver=="default")
00730                 sftver = getenv("BES_RELEASE");
00731         const char* SftVer = sftver.c_str();
00732 
00733         if(calParVer!="default"){
00734                 const char* calpar = calParVer.c_str();
00735                 sprintf(stmt1,"select WireEff,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from MdcDataConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d and CalParVer = %s",SftVer,run_No,run_No,calpar);
00736         }
00737         if(calParVer=="default"){
00738                 sprintf(stmt1,"select WireEff,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from MdcDataConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d order by CalParVer desc",SftVer,run_No,run_No);
00739         }
00740 
00741         int row_no = m_dbsvc->query("offlinedb", stmt1, res);
00742         if(row_no<1){
00743                 std::cout<<"ERROR:error searching MdcDataConst Data in the database with: "<<stmt1<<std::endl;
00744                 return RETMySQLError;
00745         }
00746 
00747         return RETOk;
00748 }

Metadata::eRet calibUtil::Metadata::getReadMDCInfo ( unsigned int  serialNo,
int *  runFrm,
int *  runTo,
std::string calParVer,
DatabaseRecordVector res,
int  runNo,
std::string sftver 
)

Definition at line 445 of file Metadata.cxx.

References m_dbsvc, IDatabaseSvc::query(), RETMySQLError, RETOk, and SftVer.

Referenced by CalibMySQLCnvSvc::createCalib(), and CalibMySQLCnvSvc::updateCalib().

00451                                            {
00452                 using namespace rdbModel;
00453                 eRet ret;
00454                 char stmt1[200];
00455                 int run_No =runNo;
00456 
00457                 if(sftver=="default")
00458                         sftver = getenv("BES_RELEASE");
00459                 const char* SftVer = sftver.c_str();
00460 
00461 
00462                 if(calParVer!="default"){
00463                         const char* calpar = calParVer.c_str();
00464                         sprintf(stmt1,"select NewXtTrees,XtTree,QtTree,T0Tree,SdTree,R2tTrees,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from MdcCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d and CalParVer = '%s'",SftVer,run_No,run_No,calpar);}
00465 
00466                         if(calParVer=="default"){
00467                                 //sprintf(stmt1,"select NewXtTrees,XtTree,QtTree,T0Tree,SdTree,R2tTrees,RunFrom,RunTo,max(CalParVer),FileName from MdcCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by CalParVer",SftVer,run_No,run_No);}
00468                                 sprintf(stmt1,"select NewXtTrees,XtTree,QtTree,T0Tree,SdTree,R2tTrees,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from MdcCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d order by CalParVer desc",SftVer,run_No,run_No);}
00469 
00470                         int row_no = m_dbsvc->query("offlinedb", stmt1, res);
00471                         if(row_no<1){
00472                                 std::cout<<"ERROR:error searching Mdc calibration Data in the database with: "<<stmt1<<std::endl;
00473                                 return RETMySQLError;
00474                         }
00475 
00476 
00477                         return RETOk;
00478 }

Metadata::eRet calibUtil::Metadata::getReadMUCInfo ( unsigned int  serialNo,
int *  runFrm,
int *  runTo,
std::string calParVer,
DatabaseRecordVector res,
int  runNo,
std::string sftver 
)

Definition at line 408 of file Metadata.cxx.

References m_dbsvc, IDatabaseSvc::query(), RETMySQLError, RETOk, and SftVer.

Referenced by CalibMySQLCnvSvc::createCalib(), and CalibMySQLCnvSvc::updateCalib().

00414                                            {
00415                 using namespace rdbModel;
00416                 eRet ret;
00417                 char stmt1[300];
00418                 int run_No =runNo;
00419                 //char* SftVer = getenv("BES_RELEASE");
00420                 if(sftver=="default")
00421                         sftver = getenv("BES_RELEASE");
00422                 const char* SftVer = sftver.c_str();
00423 
00424                 if(calParVer!="default"){
00425                         const char* calpar = calParVer.c_str();
00426                         sprintf(stmt1,"select LayTree,BoxTree,StrTree,ResTree,ClsTree,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from MucCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d  order by CalParVer desc",SftVer,run_No,run_No);     
00427                 }
00428 
00429                 if(calParVer=="default"){
00430                         //  sprintf(stmt1,"select SftVer,LayTree,BoxTree,StrTree,ResTree,ClsTree,RunFrom,RunTo,max(CalParVer),FileName from MucCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by CalParVer",SftVer,run_No,run_No);
00431                         sprintf(stmt1,"select LayTree,BoxTree,StrTree,ResTree,ClsTree,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from MucCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d  order by CalParVer desc",SftVer,run_No,run_No);
00432 
00433                 }
00434 
00435                 int row_no = m_dbsvc->query("offlinedb", stmt1, res);
00436                 if(row_no<1){
00437                         std::cout<<"ERROR:error searching MUC calibration Data in the database with: "<<stmt1<<std::endl;
00438                         return RETMySQLError;
00439                 }
00440 
00441 
00442                 return RETOk;
00443         }

Metadata::eRet calibUtil::Metadata::getReadTOFInfo ( unsigned int  serialNo,
int *  runFrm,
int *  runTo,
std::string calParVer,
DatabaseRecordVector res,
int  runNo,
std::string sftver 
)

Definition at line 376 of file Metadata.cxx.

References m_dbsvc, IDatabaseSvc::query(), RETMySQLError, RETOk, and SftVer.

Referenced by CalibMySQLCnvSvc::createCalib(), and CalibMySQLCnvSvc::updateCalib().

00382                                            {
00383                 using namespace rdbModel;
00384                 eRet ret;
00385                 char stmt1[300];
00386                 int run_No =runNo;
00387                 if(sftver=="default")
00388                         sftver = getenv("BES_RELEASE");
00389                 const char* SftVer = sftver.c_str();
00390 
00391                 if(calParVer!="default"){
00392                         const char* calpar = calParVer.c_str();
00393                         sprintf(stmt1,"select BarTofPar,EndTofPar,TofConPar,BarTof,EtfTofPar,EtfTofBunch,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from TofCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d and CalParVer = %s",SftVer,run_No,run_No,calpar);
00394                 }
00395                 if(calParVer=="default"){
00396                         sprintf(stmt1,"select BarTofPar,EndTofPar,TofConPar,BarTof,EtfTofPar,EtfTofBunch,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from TofCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d order by CalParVer desc",SftVer,run_No,run_No);
00397                 }
00398 
00399                 int row_no = m_dbsvc->query("offlinedb", stmt1, res);
00400                 if(row_no<1){
00401                         std::cout<<"ERROR:error searching TOF calibration Data in the database with: "<<stmt1<<std::endl;
00402                         return RETMySQLError;
00403                 }
00404 
00405                 return RETOk;
00406         }

Metadata::eRet calibUtil::Metadata::getReadTofQElecInfo ( unsigned int  serialNo,
int *  runFrm,
int *  runTo,
std::string calParVer,
DatabaseRecordVector res,
int  runNo,
std::string sftver 
)

Definition at line 750 of file Metadata.cxx.

References m_dbsvc, IDatabaseSvc::query(), RETMySQLError, RETOk, and SftVer.

Referenced by CalibMySQLCnvSvc::createCalib(), and CalibMySQLCnvSvc::updateCalib().

00756                                    {
00757         using namespace rdbModel;
00758         eRet ret;
00759         char stmt1[400];
00760         int run_No =runNo;
00761         if(sftver=="default")
00762                 sftver = getenv("BES_RELEASE");
00763         const char* SftVer = sftver.c_str();
00764 
00765         if(calParVer!="default"){
00766                 const char* calpar = calParVer.c_str();
00767                 sprintf(stmt1,"select BarBoardNum,EndBoardNum,QELecBarParEast,QELecBarParWest,QELecEndPar,SimQELecBarParEast,SimQELecBarParWest,SimQELecEndPar,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from TofQELec where SftVer = '%s' and RunFrom <= %d and RunTo >= %d and CalParVer = %s",SftVer,run_No,run_No,calpar);
00768         }
00769         if(calParVer=="default"){
00770                 sprintf(stmt1,"select BarBoardNum,EndBoardNum,QELecBarParEast,QELecBarParWest,QELecEndPar,SimQELecBarParEast,SimQELecBarParWest,SimQELecEndPar,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from TofQELec where SftVer = '%s' and RunFrom <= %d and RunTo >= %d order by CalParVer desc",SftVer,run_No,run_No);
00771         }
00772         int row_no = m_dbsvc->query("offlinedb", stmt1, res);
00773         if(row_no<1){
00774                 std::cout<<"ERROR:error searching TofQElec calibration Data in the database with: "<<stmt1<<std::endl;
00775                 return RETMySQLError;
00776         }
00777         std::cout<<"metadata ok"<<std::endl;
00778         return RETOk;
00779 }

Metadata::eRet calibUtil::Metadata::getReadTofSimInfo ( unsigned int  serialNo,
int *  runFrm,
int *  runTo,
std::string calParVer,
DatabaseRecordVector res,
int  runNo,
std::string sftver 
)

Definition at line 617 of file Metadata.cxx.

References m_dbsvc, IDatabaseSvc::query(), RETMySQLError, RETOk, and SftVer.

Referenced by CalibMySQLCnvSvc::createCalib(), and CalibMySQLCnvSvc::updateCalib().

00623                                    {
00624         using namespace rdbModel;
00625         eRet ret;
00626         char stmt1[200];
00627         int run_No =runNo;
00628         if(sftver=="default")
00629                 sftver = getenv("BES_RELEASE");
00630         const char* SftVer = sftver.c_str();
00631 
00632         if(calParVer!="default"){
00633                 const char* calpar = calParVer.c_str();
00634                 sprintf(stmt1,"select BTofSim,ETofSim,SimConstants,RunFrom,RunTo,TofSimParVer,FileName,Status,SftVer from TofSimSvc where SftVer = '%s' and RunFrom <= %d and RunTo >= %d and TofSimParVer = %s",SftVer,run_No,run_No,calpar);
00635         }
00636         if(calParVer=="default"){
00637                 // sprintf(stmt1,"select  BTofSim,ETofSim,SimConstants,RunFrom,RunTo,max(TofSimParVer),FileName from TofSimSvc where SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by TofSimParVer",SftVer,run_No,run_No);
00638                 sprintf(stmt1,"select  BTofSim,ETofSim,SimConstants,RunFrom,RunTo,TofSimParVer,FileName,Status,SftVer from TofSimSvc where SftVer = '%s' and RunFrom <= %d and RunTo >= %d order by TofSimParVer desc",SftVer,run_No,run_No);
00639         }
00640 
00641 
00642         int row_no = m_dbsvc->query("offlinedb", stmt1, res);
00643         if(row_no<1){
00644                 std::cout<<"ERROR:error searching TOFSim calibration Data in the database with: "<<stmt1<<std::endl;
00645                 return RETMySQLError;
00646         }
00647 
00648         return RETOk;
00649 }

const std::string& calibUtil::Metadata::getTable (  )  [inline]

Definition at line 286 of file Metadata.h.

References m_table.

00286 {return m_table;}

int calibUtil::Metadata::registerCalib ( const std::string inst,
const std::string flavor,
const std::string calib_type,
const std::string data_ident,
const std::string data_format,
unsigned int &  runfrm,
unsigned int &  runto,
const std::string input_desc,
const std::string notes,
const std::string proc_level,
const std::string locale,
const std::string fmt_version = "",
const std::string completion = "OK" 
)

Definition at line 865 of file Metadata.cxx.

References adjustVend(), checkNulls(), checkValues(), connectWrite(), fetchUser(), facilities::Timestamp::getString(), rdbModel::Connection::insertRow(), RawFileTools::itoa(), m_rdb, m_table, m_writeCxt, RETOk, and deljobs::string.

00878 {
00879 
00880         using namespace rdbModel;
00881 
00882         eRet ret;
00883 
00884         if (!m_writeCxt) {
00885                 connectWrite(ret);
00886                 if (ret != RETOk) return 0; // we or connectWrite should throw exception
00887         }
00888         StringVector cols;
00889         StringVector vals;
00890         StringVector nullCols;
00891 
00892         cols.reserve(24);
00893         vals.reserve(24);
00894         nullCols.reserve(16);
00895 
00896         if (inst.size() * calib_type.size() * flavor.size() * data_fmt.size() 
00897                         * data_ident.size() * proc_level.size() * completion.size() 
00898                         * locale.size() == 0) {   // something is null that shouldn't be
00899                 return 0;      // should perhaps throw exception
00900         }
00901         cols.push_back("calib_type"); vals.push_back(calib_type);
00902         // cols.push_back("flavor"); vals.push_back(flavor);
00903         cols.push_back("data_fmt"); vals.push_back(data_fmt);
00904         cols.push_back("data_ident"); vals.push_back(data_ident);
00905         cols.push_back("status"); vals.push_back(completion);
00906         std::string s_runfrm,s_runto;
00907         facilities::Util::itoa(runfrm,s_runfrm);
00908         facilities::Util::itoa(runto,s_runto);
00909         cols.push_back("RunFrom"); vals.push_back(s_runfrm);
00910         cols.push_back("RunTo"); vals.push_back(s_runto);
00911 
00912         //  These, however, may be null
00913         if (input_desc.size() > 0 ) {
00914                 cols.push_back("input_desc"); vals.push_back(input_desc); 
00915         }  else nullCols.push_back("input_desc");
00916 
00917         if (notes.size() > 0 ) {
00918                 cols.push_back("notes"); vals.push_back(notes);
00919         }    else nullCols.push_back("notes");
00920 
00921         if (fmt_version.size() > 0 )
00922         {
00923                 cols.push_back("fmt_version"); 
00924                 vals.push_back(fmt_version);
00925         } 
00926 
00927         // The service -- that's us -- is responsible for creator, uid, enter_time
00928         cols.push_back("creator"); vals.push_back("Metadata::registerCalib");
00929         std::string uid;
00930         fetchUser(uid);
00931         cols.push_back("uid"); vals.push_back(uid);
00932         facilities::Timestamp curTime;
00933         cols.push_back("enter_time");vals.push_back(curTime.getString());
00934         // update_time is set automatically by MySQL, but MySQL uses
00935         // local timezone rather than gmt, so we have set it explicitly
00936         cols.push_back("update_time");vals.push_back(curTime.getString());
00937 
00938 
00939         if (m_rdb) {
00940                 bool ok = checkValues(cols, vals);
00941                 if (ok) checkNulls(nullCols);
00942                 if (!ok) return 0;
00943         }
00944 
00945         // ser_no gets set automatically by MySQL
00946         int ser_no;
00947         if (!(m_writeCxt->insertRow(m_table, cols, vals, &ser_no, &nullCols)) ) {
00948                 return 0;
00949         }    else {
00950                 adjustVend(ser_no);
00951                 return ser_no;
00952         }
00953 }


Member Data Documentation

std::string calibUtil::Metadata::m_dbName [private]

Definition at line 369 of file Metadata.h.

Referenced by connectRead(), and connectWrite().

IDatabaseSvc* calibUtil::Metadata::m_dbsvc [private]

Definition at line 372 of file Metadata.h.

Referenced by getReadDedxInfo(), getReadDedxSimInfo(), getReadEMCInfo(), getReadEsTimeInfo(), getReadEstTofInfo(), getReadMdcAlignInfo(), getReadMdcDataConstInfo(), getReadMDCInfo(), getReadMUCInfo(), getReadTOFInfo(), getReadTofQElecInfo(), getReadTofSimInfo(), and Metadata().

rdbModel::Assertion* calibUtil::Metadata::m_findBest [private]

Definition at line 298 of file Metadata.h.

rdbModel::Assertion* calibUtil::Metadata::m_findSoonest [private]

Definition at line 299 of file Metadata.h.

std::string calibUtil::Metadata::m_host [private]

Constant bit mask indicating all necessary fields have been set.

Keep track of which columns in row have been initialized with bit mask

Definition at line 367 of file Metadata.h.

Referenced by connectRead(), connectWrite(), and Metadata().

rdbModel::Manager* calibUtil::Metadata::m_man [private]

Definition at line 370 of file Metadata.h.

Referenced by compareSchema(), and ~Metadata().

bool calibUtil::Metadata::m_match [private]

Definition at line 373 of file Metadata.h.

Referenced by compareSchema().

rdbModel::Rdb* calibUtil::Metadata::m_rdb [private]

Definition at line 371 of file Metadata.h.

Referenced by checkNulls(), checkValues(), compareSchema(), getRdb(), and registerCalib().

rdbModel::Connection* calibUtil::Metadata::m_readCxt [private]

Definition at line 294 of file Metadata.h.

Referenced by connectRead(), connectWrite(), disconnectRead(), doSelect(), findBest(), findSoonAfter(), getReadConnection(), and getReadInfo().

std::string calibUtil::Metadata::m_table [private]

Definition at line 368 of file Metadata.h.

Referenced by adjustVend(), checkNulls(), checkValues(), doSelect(), getReadInfo(), getTable(), Metadata(), and registerCalib().

rdbModel::Connection* calibUtil::Metadata::m_writeCxt [private]

Definition at line 295 of file Metadata.h.

Referenced by adjustVend(), connectWrite(), disconnectWrite(), and registerCalib().


Generated on Tue Nov 29 23:36:24 2016 for BOSS_7.0.2 by  doxygen 1.4.7