BOSS_7.0.2: /home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Calibration/calibUtil/calibUtil-00-00-43/src/Metadata.cxx Source File

00001 // $Header: /bes/bes/BossCvs/Calibration/calibUtil/src/Metadata.cxx,v 1.42 2016/05/27 02:56:18 sunss Exp $
00002 
00003 /*
00004 #ifdef  WIN32
00005 #include <windows.h>
00006 #endif
00007 */
00008 
00009 #include "calibUtil/Metadata.h"
00010 #include "facilities/Util.h"
00011 #include "facilities/Timestamp.h"
00012 #include "rdbModel/Management/Manager.h"
00013 #include "rdbModel/Management/XercesBuilder.h"
00014 #include "GaudiKernel/Bootstrap.h"
00015 #include "GaudiKernel/ISvcLocator.h"
00016 
00017 
00018 
00019 #include "rdbModel/Db/MysqlConnection.h"
00020 #include "rdbModel/Db/MysqlResults.h"
00021 #include "rdbModel/Rdb.h"
00022 #include "rdbModel/RdbException.h"
00023 #include "rdbModel/Tables/Assertion.h"
00024 #include "rdbModel/Tables/Table.h"
00025 #include "rdbModel/Tables/Column.h"
00026 #include <iostream>
00027 #include <cstdio>
00028 #include <mysql.h>
00029 #include "TTree.h"
00030 #include "TBuffer.h"
00031 
00032 
00033 namespace calibUtil {
00034 
00035         // Might be getting rid of this
00036         //  const unsigned int Metadata::s_rowReady = Metadata::eOpened 
00037         //  | Metadata::eValid  | Metadata::eInputDesc | Metadata::eComment;
00038 
00039         Metadata::Metadata(const std::string& host, const std::string& table,
00040                         const std::string& dbName)  
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                 }
00056 
00057         Metadata::~Metadata() {
00058                 disconnectRead();
00059                 disconnectWrite();
00060                 if (m_man) delete m_man;
00061         }
00062 
00063 
00064         Metadata::eRet Metadata::fetchUser(std::string& user) {
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         }
00083 
00084         // The next 5 methods concern connection to the server
00085         bool Metadata::connect(rdbModel::Connection* cxt, std::string& host,
00086                         const std::string& user, 
00087                         const std::string& pw, eRet& err,
00088                         const std::string& dbName)  {
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         }
00106 
00107         bool Metadata::connectRead(eRet& err) {
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         }
00128 
00129         bool Metadata::connectWrite(eRet& err) {
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         }
00154 
00155         void Metadata::disconnectRead() {
00156                 if (m_readCxt) {
00157                         m_readCxt->close();
00158                         delete m_readCxt;
00159                         m_readCxt = 0;
00160                 }
00161         }
00162 
00163         void Metadata::disconnectWrite() {
00164                 if (m_writeCxt) {
00165                         m_writeCxt->close();
00166                         delete m_writeCxt;
00167                         m_writeCxt = 0;
00168                 }
00169         }
00170 
00171         Metadata::eRet 
00172                 Metadata::findSoonAfter(unsigned int *ser,
00173                                 const std::string& calibType,
00174                                 const std::string& SftVer,
00175                                 const std::string& cal_ver, 
00176                                 const std::string& cal_par,
00177                                 const std::string& rec_alg,
00178                                 const std::string& rec_par,
00179                                 const std::string& machine,
00180                                 const std::string& flavor) {
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                 }
00242 
00243         Metadata::eRet Metadata::findBest(unsigned int *ser,
00244                         const std::string& calibType,
00245                         const std::string& SftVer,
00246                         const std::string& cal_ver,
00247                         const std::string& cal_par,
00248                         const std::string& rec_alg,
00249                         const std::string& rec_par,
00250                         const std::string& machine,
00251                         const std::string& flavor)
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         }
00312 
00313 
00314         Metadata::eRet Metadata::getReadInfo(unsigned int serialNo, 
00315                         int *runFrm,
00316                         int *runTo,
00317                         std::string& dataFmt, 
00318                         std::string& filename) {
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         }
00375 
00376         Metadata::eRet Metadata::getReadTOFInfo(unsigned int serialNo, 
00377                         int *runFrm,
00378                         int *runTo,
00379                         std::string& calParVer,
00380                         DatabaseRecordVector& res,
00381                         int runNo,
00382                         std::string& sftver) {
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         }
00407 
00408         Metadata::eRet Metadata::getReadMUCInfo(unsigned int serialNo, 
00409                         int *runFrm,
00410                         int *runTo,
00411                         std::string& calParVer,
00412                         DatabaseRecordVector& res,
00413                         int runNo,
00414                         std::string& sftver) {
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         }
00444 
00445         Metadata::eRet Metadata::getReadMDCInfo(unsigned int serialNo, 
00446                         int *runFrm,
00447                         int *runTo,
00448                         std::string& calParVer,
00449                         DatabaseRecordVector& res,
00450                         int runNo,
00451                         std::string& sftver) {
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 }
00479 
00480 
00481 
00482 Metadata::eRet Metadata::getReadEMCInfo(unsigned int serialNo, 
00483                 int *runFrm,
00484                 int *runTo,
00485                 std::string& calParVer,
00486                 DatabaseRecordVector& res,
00487                 int runNo,
00488                 std::string& sftver) {
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 }
00514 
00515 
00516 Metadata::eRet Metadata::getReadDedxInfo(unsigned int serialNo, 
00517                 int *runFrm,
00518                 int *runTo,
00519                 std::string& calParVer,
00520                 DatabaseRecordVector& res,
00521                 int runNo,
00522                 std::string& sftver) {
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 }
00548 
00549 
00550 Metadata::eRet Metadata::getReadEsTimeInfo(unsigned int serialNo,   
00551                 int *runFrm,   
00552                 int *runTo,   
00553                 std::string& calParVer,   
00554                 DatabaseRecordVector& res,
00555                 int runNo,
00556                 std::string& sftver) {   
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 } 
00581 
00582 
00583 //get EstTof Information from mysql Database
00584 Metadata::eRet Metadata::getReadEstTofInfo(unsigned int serialNo,
00585                 int *runFrm,
00586                 int *runTo,
00587                 std::string& calParVer,
00588                 DatabaseRecordVector& res,
00589                 int runNo,
00590                 std::string& sftver) {
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 }
00615 
00616 
00617 Metadata::eRet Metadata::getReadTofSimInfo(unsigned int serialNo,
00618                 int *runFrm,
00619                 int *runTo,
00620                 std::string& calParVer,
00621                 DatabaseRecordVector& res,
00622                 int runNo,
00623                 std::string& sftver) {
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 }
00650 
00651 
00652 Metadata::eRet Metadata::getReadDedxSimInfo(unsigned int serialNo,
00653                 int *runFrm,
00654                 int *runTo,
00655                 std::string& calParVer,
00656                 DatabaseRecordVector& res,
00657                 int runNo,
00658                 std::string& sftver) {
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 }
00682 
00683 
00684 
00685 Metadata::eRet Metadata::getReadMdcAlignInfo(unsigned int serialNo,
00686                 int *runFrm,
00687                 int *runTo,
00688                 std::string& calParVer,
00689                 DatabaseRecordVector& res,
00690                 int runNo,
00691                 std::string& sftver) {
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 }
00717 
00718 Metadata::eRet Metadata::getReadMdcDataConstInfo(unsigned int serialNo,
00719                 int *runFrm,
00720                 int *runTo,
00721                 std::string& calParVer,
00722                 DatabaseRecordVector& res,
00723                 int runNo,
00724                 std::string& sftver) {
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 }
00749 
00750 Metadata::eRet Metadata::getReadTofQElecInfo(unsigned int serialNo,
00751                 int *runFrm,
00752                 int *runTo,
00753                 std::string& calParVer,
00754                 DatabaseRecordVector& res,
00755                 int runNo,
00756                 std::string& sftver) {
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 }
00780 
00781 
00782 /*
00783 
00784          | Field       | Type               | Null | Key | Default | How set          |
00785          +-------------+--------------------+------+-----+---------+------------------+
00786          | ser_no      | mediumint(9)       |      | PRI | NULL    | auto_increment   |
00787          | instrument  | varchar(16)        |      |     |         |   [openRecord]   |
00788          | calib_type  | varchar(20)        |      |     |         |   [openRecord    |
00789          | data_fmt    | varchar(10)        |      |     |         |   [openRecord]   |
00790          | data_size   | int(11)            | YES  |     | NULL    |   [optional]     |
00791          | vstart      | datetime           | YES  |     | NULL    |[addValidInterval]|
00792          | vend        | datetime           | YES  |     | NULL    |[addValidInterval]|
00793          | enter_time  | timestamp(14)      | YES  |     | NULL    | automatic        |
00794          | fmt_version | varchar(12)        | YES  |     | NULL    |   [openRecord]   |
00795          | completion  | enum('OK','INC','ABORT')           
00796          | YES  | MUL | NULL    |   [openRecord]   |
00797          | proc_level  | enum('PROD','TEST','DEV', 'SUPSED')
00798          |      |     | TEST    |   [openRecord]   |
00799          | creator     | varchar(255)       | YES  |     | NULL    |   [addCreator]   |
00800          | uid         | varchar(12)        |      |     |         |[insertRecord/
00801          addUser]        |
00802          | data_ident  | varchar(255)       |      |     |         |   [openRecord]   |
00803          | input_desc  | varchar(255)       | YES  |     | NULL    |[addInputDesc]    |
00804          | notes       | varchar(255)       | YES  |     | NULL    |   [addNotes]     |
00805          +-------------+--------------------+------+-----+---------+------------------+
00806 
00807 */
00808 
00809 Metadata::eRet 
00810 Metadata::doSelect(std::vector<rdbModel::Assertion::Operator *>& conditions, 
00811                 rdbModel::StringVector& orderBy,
00812                 unsigned*& ser) {
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 }
00864 
00865 int  Metadata::registerCalib(const std::string& inst, 
00866                 const std::string& flavor,
00867                 const std::string& calib_type, 
00868                 const std::string& data_ident,
00869                 const std::string& data_fmt,
00870                 unsigned int& runfrm,
00871                 unsigned int& runto,
00872                 const std::string& input_desc, 
00873                 const std::string& notes,
00874                 const std::string& proc_level,
00875                 const std::string& locale,
00876                 const std::string& fmt_version,
00877                 const std::string& completion)
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 }
00954 
00955 Metadata::eRet Metadata::compareSchema(rdbModel::Connection* conn,
00956                 const std::string& schema) {
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 }
00998 
00999 bool Metadata::checkValues(const rdbModel::StringVector& cols,
01000                 const rdbModel::StringVector& vals) const {
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 }
01015 
01016 bool Metadata::checkNulls(const rdbModel::StringVector& cols) const {
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 }
01032 
01033 
01034 unsigned Metadata::adjustVend(int newSer) {
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 }
01127 
01128 }
01129 
01130