BOSS 8.0.0
BESIII Offline Software System
Loading...
Searching...
No Matches
Metadata.cxx
Go to the documentation of this file.
1// $Header: /bes/bes/BossCvs/Calibration/calibUtil/src/Metadata.cxx,v 1.45 2020/09/28 05:22:41
2// maqm Exp $
3
4/*
5#ifdef WIN32
6#include <windows.h>
7#endif
8*/
9
10#include "GaudiKernel/Bootstrap.h"
11#include "GaudiKernel/ISvcLocator.h"
12#include "calibUtil/Metadata.h"
13#include "facilities/Timestamp.h"
14#include "facilities/Util.h"
15#include "rdbModel/Management/Manager.h"
16#include "rdbModel/Management/XercesBuilder.h"
17
18#include "TBuffer.h"
19#include "TTree.h"
20#include "rdbModel/Db/MysqlConnection.h"
21#include "rdbModel/Db/MysqlResults.h"
22#include "rdbModel/Rdb.h"
23#include "rdbModel/RdbException.h"
24#include "rdbModel/Tables/Assertion.h"
25#include "rdbModel/Tables/Column.h"
26#include "rdbModel/Tables/Table.h"
27#include <cstdio>
28#include <iostream>
29#include <mysql.h>
30using namespace std;
31
32namespace calibUtil {
33
34 // Might be getting rid of this
35 // const unsigned int Metadata::s_rowReady = Metadata::eOpened
36 // | Metadata::eValid | Metadata::eInputDesc | Metadata::eComment;
37
38 Metadata::Metadata( const std::string& host, const std::string& table,
39 const std::string& dbName )
40 : m_readCxt( 0 )
41 , m_writeCxt( 0 )
42 , // m_row(""), m_rowStatus(0),
43 m_host( host )
44 , m_table( table )
45 , m_dbName( dbName )
46 , m_man( 0 )
47 , m_rdb( 0 )
48 , m_match( false ) {
49 if ( table.compare( "*" ) == 0 ) m_table = std::string( "$(MYSQL_METATABLE)" );
50 if ( host.compare( "*" ) == 0 ) m_host = std::string( "$(MYSQL_HOST)" );
51
52 int nsub = facilities::Util::expandEnvVar( &m_table );
53 // If this doesn't work, use default
54 if ( nsub < 0 ) m_table = std::string( "metadata" );
55 StatusCode sc = Gaudi::svcLocator()->service( "DatabaseSvc", m_dbsvc, true );
56 if ( !sc.isSuccess() )
57 {
58 std::cout << "Metadata ERROR ::Could not retrieve the DataBaseSvc" << std::endl;
59 ;
60 exit( 1 );
61 }
62 }
63
64 Metadata::~Metadata() {
65 disconnectRead();
66 disconnectWrite();
67 if ( m_man ) delete m_man;
68 }
69
70 Metadata::eRet Metadata::fetchUser( std::string& user ) {
71 // WARNING: Windows and Linux/Solaris use different standard variables
72 // for login name. The test used below isn't quite right
73 // since one could conceivably compile with gcc on cygwin/Windows.
74#ifdef __GNUG__
75 user = std::string( "$(USER)" );
76#else
77 user = std::string( "$(USERNAME)" );
78#endif
79
80 int nsub = facilities::Util::expandEnvVar( &user );
81 if ( nsub == 1 ) { return RETOk; }
82 else
83 {
84 user = std::string( "" );
85 return RETBadValue;
86 }
87 }
88
89 // The next 5 methods concern connection to the server
90 bool Metadata::connect( rdbModel::Connection* cxt, std::string& host,
91 const std::string& user, const std::string& pw, eRet& err,
92 const std::string& dbName ) {
93
94 int nSub = facilities::Util::expandEnvVar( &host );
95 if ( nSub < 0 )
96 {
97 err = RETBadHost;
98 return false;
99 }
100
101 bool connected = cxt->open( host, user, pw, dbName );
102 if ( connected )
103 {
104 err = RETOk;
105 return true;
106 }
107 else
108 {
109 err = RETNoConnect;
110 return false;
111 }
112 }
113
114 bool Metadata::connectRead( eRet& err ) {
115 if ( m_readCxt == 0 )
116 {
117 // for now use std::cout, std::cerr
118 m_readCxt = new rdbModel::MysqlConnection();
119 // bool ok = connect(m_readCxt, m_host, std::string("maqm"),
120 // std::string("maqm_offline"), err, m_dbName);
121 bool ok = connect( m_readCxt, m_host, std::string( "guest" ), std::string( "guestpass" ),
122 err, m_dbName );
123 if ( !ok )
124 {
125 delete m_readCxt;
126 m_readCxt = 0;
127 } /* else { // look for compatible schema
128 std::string schema =
129 std::string("$(RDBMODELROOT)/xml/")+ m_dbName + ".xml";
130 err = compareSchema(m_readCxt, schema);
131 }*/
132 return ok;
133 }
134
135 else return true;
136 }
137
138 bool Metadata::connectWrite( eRet& err ) {
139 if ( m_writeCxt == 0 )
140 {
141 m_writeCxt = new rdbModel::MysqlConnection();
142 bool ok;
143 if ( m_dbName == std::string( "calib_test" ) )
144 {
145 ok = connect( m_writeCxt, m_host, std::string( "calib_tester" ),
146 std::string( "udine" ), err, m_dbName );
147 }
148 else
149 {
150 ok = connect( m_writeCxt, m_host, std::string( "calibrator" ),
151 std::string( "calibrator" ), err, m_dbName );
152 }
153 if ( !ok )
154 {
155 delete m_readCxt;
156 m_readCxt = 0;
157 }
158 else
159 { // look for compatible schema
160 std::string schema = std::string( "$(RDBMODELROOT)/xml/" ) + m_dbName + ".xml";
161 err = compareSchema( m_writeCxt, schema );
162 }
163
164 return ok;
165 }
166 else return true;
167 }
168
169 void Metadata::disconnectRead() {
170 if ( m_readCxt )
171 {
172 m_readCxt->close();
173 delete m_readCxt;
174 m_readCxt = 0;
175 }
176 }
177
178 void Metadata::disconnectWrite() {
179 if ( m_writeCxt )
180 {
181 m_writeCxt->close();
182 delete m_writeCxt;
183 m_writeCxt = 0;
184 }
185 }
186
187 Metadata::eRet Metadata::findSoonAfter(
188 unsigned int* ser, const std::string& calibType, const std::string& SftVer,
189 const std::string& cal_ver, const std::string& cal_par, const std::string& rec_alg,
190 const std::string& rec_par, const std::string& machine, const std::string& flavor ) {
191 using namespace rdbModel;
192
193 eRet ret;
194 *ser = 0;
195 if ( !m_readCxt )
196 {
197 connectRead( ret );
198 if ( ret != RETOk ) return ret;
199 }
200
201 StringVector orderBy;
202
203 std::vector<Assertion::Operator*> conditions;
204 conditions.reserve( 8 );
205
206 Assertion::Operator completeOp( OPTYPEequal, "status", "OK", FIELDTYPEold, FIELDTYPElit );
207 // false, true);
208 Assertion::Operator calibTypeOp( OPTYPEequal, "calib_type", calibType, FIELDTYPEold,
209 FIELDTYPElit );
210 // false, true);
211 // Assertion::Operator flavorOp(OPTYPEequal, "flavor", flavor,
212 // FIELDTYPEold, FIELDTYPElit);
213 // false, true);
214 Assertion::Operator sftverOp( OPTYPEequal, "SftVer", SftVer, FIELDTYPEold, FIELDTYPElit );
215 Assertion::Operator calverOp( OPTYPEequal, "cal_ver", cal_ver, FIELDTYPEold,
216 FIELDTYPElit );
217 Assertion::Operator calparOp( OPTYPEequal, "cal_par", cal_par, FIELDTYPEold,
218 FIELDTYPElit );
219 Assertion::Operator recalgOp( OPTYPEequal, "rec_alg", rec_alg, FIELDTYPEold,
220 FIELDTYPElit );
221 Assertion::Operator recparOp( OPTYPEequal, "rec_par", rec_par, FIELDTYPEold,
222 FIELDTYPElit );
223 Assertion::Operator machineOp( OPTYPEequal, "machine", machine, FIELDTYPEold,
224 FIELDTYPElit );
225
226 int run = 10005;
227 std::string s_run;
228 std::cout << "run no is::" << s_run << std::endl;
229 facilities::Util::itoa( run, s_run );
230 Assertion::Operator runfrmOp( OPTYPElessOrEqual, "RunFrom", s_run, FIELDTYPEold,
231 FIELDTYPElit );
232
233 Assertion::Operator runtoOp( OPTYPEgreaterOrEqual, "RunTo", s_run, FIELDTYPEold,
234 FIELDTYPElit );
235
236 conditions.push_back( &completeOp );
237 conditions.push_back( &calibTypeOp );
238 // conditions.push_back(&flavorOp);
239 conditions.push_back( &sftverOp );
240 conditions.push_back( &calverOp );
241 conditions.push_back( &calparOp );
242 conditions.push_back( &recalgOp );
243 conditions.push_back( &recparOp );
244 conditions.push_back( &machineOp );
245 conditions.push_back( &runfrmOp );
246 conditions.push_back( &runtoOp );
247 ret = doSelect( conditions, orderBy, ser );
248
249 return ret;
250 }
251
252 Metadata::eRet Metadata::findBest( unsigned int* ser, const std::string& calibType,
253 const std::string& SftVer, const std::string& cal_ver,
254 const std::string& cal_par, const std::string& rec_alg,
255 const std::string& rec_par, const std::string& machine,
256 const std::string& flavor ) {
257 using namespace rdbModel;
258
259 eRet ret;
260 *ser = 0;
261 if ( !m_readCxt )
262 {
263 connectRead( ret );
264 if ( ret != RETOk ) return ret;
265 }
266
267 // Sort rows by timestamp. Would like most recent first
268 StringVector orderBy;
269
270 std::vector<Assertion::Operator*> conditions;
271 conditions.reserve( 8 );
272 Assertion::Operator completeOp( OPTYPEequal, "status", "OK", FIELDTYPEold, FIELDTYPElit );
273 // false, true);
274
275 Assertion::Operator calibTypeOp( OPTYPEequal, "calib_type", calibType, FIELDTYPEold,
276 FIELDTYPElit );
277 // false, true);
278 // Assertion::Operator flavorOp(OPTYPEequal, "flavor", flavor,
279 // FIELDTYPEold, FIELDTYPElit);
280 // false, true);
281 Assertion::Operator sftverOp( OPTYPEequal, "SftVer", SftVer, FIELDTYPEold, FIELDTYPElit );
282 Assertion::Operator calverOp( OPTYPEequal, "cal_ver", cal_ver, FIELDTYPEold,
283 FIELDTYPElit );
284 Assertion::Operator calparOp( OPTYPEequal, "cal_par", cal_par, FIELDTYPEold,
285 FIELDTYPElit );
286 Assertion::Operator recalgOp( OPTYPEequal, "rec_alg", rec_alg, FIELDTYPEold,
287 FIELDTYPElit );
288 Assertion::Operator recparOp( OPTYPEequal, "rec_par", rec_par, FIELDTYPEold,
289 FIELDTYPElit );
290 Assertion::Operator machineOp( OPTYPEequal, "machine", machine, FIELDTYPEold,
291 FIELDTYPElit );
292 int run = 10005;
293 std::string s_run;
294 facilities::Util::itoa( run, s_run );
295 Assertion::Operator runfrmOp( OPTYPElessOrEqual, "RunFrom", s_run, FIELDTYPEold,
296 FIELDTYPElit );
297
298 Assertion::Operator runtoOp( OPTYPEgreaterOrEqual, "RunTo", s_run, FIELDTYPEold,
299 FIELDTYPElit );
300
301 conditions.push_back( &completeOp );
302 conditions.push_back( &calibTypeOp );
303 // conditions.push_back(&flavorOp);
304 conditions.push_back( &sftverOp );
305 conditions.push_back( &calverOp );
306 conditions.push_back( &calparOp );
307 conditions.push_back( &recalgOp );
308 conditions.push_back( &recparOp );
309 conditions.push_back( &machineOp );
310 conditions.push_back( &runfrmOp );
311 conditions.push_back( &runtoOp );
312 // Finally, set a value for PROC_LEVEL and make the query (ies)
313 return doSelect( conditions, orderBy, ser );
314 }
315
316 Metadata::eRet Metadata::getReadInfo( unsigned int serialNo, int* runFrm, int* runTo,
317 std::string& dataFmt, std::string& filename ) {
318 using namespace rdbModel;
319 eRet ret;
320 if ( !m_readCxt )
321 {
322 connectRead( ret );
323 if ( ret != RETOk ) { return ret; }
324 }
325 StringVector colNames( 4 );
326 colNames[0] = "data_fmt";
327 colNames[1] = "data_ident";
328 colNames[2] = "RunFrom";
329 colNames[3] = "RunTo";
330
331 std::string serNoVal;
332 facilities::Util::itoa( serialNo, serNoVal );
333 Assertion::Operator* serOp =
334 new Assertion::Operator( OPTYPEequal, "ser_no", serNoVal, FIELDTYPEold, FIELDTYPElit );
335 // false, true);
336 Assertion whereClause( serOp );
337 StringVector orderBy;
338 orderBy.clear();
339
340 // make the query
341 ResultHandle* results = 0;
342 try
343 {
344 results = m_readCxt->select( m_table, colNames, orderBy, &whereClause );
345 } catch ( RdbException ex )
346 {
347 std::cout << ex.getMsg();
348 return RETMySQLError;
349 }
350
351 if ( !results ) return RETMySQLError;
352 if ( !results->getNRows() ) return RETBadValue;
353
354 std::vector<std::string> fields;
355 std::cout << "test id \\" << std::endl;
356 results->getRow( fields );
357 dataFmt = fields[0];
358 filename = fields[1];
359 std::string runfrm, runto;
360 runfrm = fields[2];
361 runto = fields[3];
362 *runFrm = facilities::Util::atoi( runfrm );
363 *runTo = facilities::Util::atoi( runto );
364 delete results;
365 // runFrm=fields[2];
366 // runTo=fields[3];
367 // std::cout<<"runfrm is:"<<runFrm<<"runto is:"<<runTo<<std::endl;
368 if ( ( dataFmt == "" ) || ( filename == "" ) ) return RETBadValue;
369 return RETOk;
370 }
371
372 // InjSigInterval Qiumei Ma
373 Metadata::eRet Metadata::getReadInjSigIntervalInfo( unsigned int serialNo, int* runFrm,
374 int* runTo, std::string& calParVer,
375 DatabaseRecordVector& res, int runNo,
376 std::string& sftver ) {
377 using namespace rdbModel;
378 eRet ret;
379 char stmt1[200];
380 int run_No = runNo;
381
382 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
383 const char* SftVer = sftver.c_str();
384
385 if ( calParVer != "default" )
386 {
387 const char* calpar = calParVer.c_str();
388 sprintf( stmt1,
389 "select SigInterval,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from "
390 "InjSigInterval where SftVer = "
391 "'%s' and RunFrom <= %d and RunTo >= %d and CalParVer = '%s'",
392 SftVer, run_No, run_No, calpar );
393 }
394
395 if ( calParVer == "default" )
396 {
397 sprintf( stmt1,
398 "select SigInterval,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from "
399 "InjSigInterval where SftVer = "
400 "'%s' and RunFrom <= %d and RunTo >= %d order by CalParVer desc",
401 SftVer, run_No, run_No );
402 }
403 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
404 if ( row_no < 1 )
405 {
406 std::cout
407 << "ERROR:error searching InjSigInterval calibration Data in the database with: "
408 << stmt1 << std::endl;
409 return RETMySQLError;
410 }
411 int RunFrom, RunTo;
412 DatabaseRecord& records = *res[0];
413 sscanf( records["RunFrom"], "%d", &RunFrom );
414 sscanf( records["RunTo"], "%d", &RunTo );
415 cout << "@table SigInterval: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
416 return RETOk;
417 }
418
419 Metadata::eRet Metadata::getReadInjSigTimeInfo( unsigned int serialNo, int* runFrm,
420 int* runTo, std::string& calParVer,
421 DatabaseRecordVector& res, int runNo,
422 std::string& sftver ) {
423 using namespace rdbModel;
424 eRet ret;
425 char stmt1[200];
426 int run_No = runNo;
427
428 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
429 const char* SftVer = sftver.c_str();
430 cout << "getReadInjSigTimeInfo start:::::" << endl;
431 if ( calParVer != "default" )
432 {
433 const char* calpar = calParVer.c_str();
434 sprintf( stmt1,
435 "select ist,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from InjSigTime "
436 "where SftVer = '%s' and "
437 "RunFrom <= %d and RunTo >= %d and CalParVer = '%s'",
438 SftVer, run_No, run_No, calpar );
439 }
440
441 if ( calParVer == "default" )
442 {
443 sprintf( stmt1,
444 "select ist,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from InjSigTime "
445 "where SftVer = '%s' and "
446 "RunFrom <= %d and RunTo >= %d order by CalParVer desc",
447 SftVer, run_No, run_No );
448 }
449 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
450 if ( row_no < 1 )
451 {
452 std::cout << "ERROR:error searching InjSigTime calibration Data in the database with: "
453 << stmt1 << std::endl;
454 return RETMySQLError;
455 }
456 int RunFrom, RunTo;
457 DatabaseRecord& records = *res[0];
458 sscanf( records["RunFrom"], "%d", &RunFrom );
459 sscanf( records["RunTo"], "%d", &RunTo );
460 cout << "@table InjSigTimeInfo: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
461 return RETOk;
462 }
463
464 Metadata::eRet Metadata::getReadOffEvtFilterInfo( unsigned int serialNo, int* runFrm,
465 int* runTo, std::string& calParVer,
466 DatabaseRecordVector& res, int runNo,
467 std::string& sftver ) {
468 using namespace rdbModel;
469 eRet ret;
470 char stmt1[200];
471 int run_No = runNo;
472
473 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
474 const char* SftVer = sftver.c_str();
475 if ( calParVer != "default" )
476 {
477 const char* calpar = calParVer.c_str();
478 sprintf( stmt1,
479 "select data,oef,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from "
480 "OffEvtFilter where SftVer = '%s' "
481 "and RunFrom <= %d and RunTo >= %d and CalParVer = '%s'",
482 SftVer, run_No, run_No, calpar );
483 }
484
485 if ( calParVer == "default" )
486 {
487 sprintf( stmt1,
488 "select data,oef,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from "
489 "OffEvtFilter where SftVer = '%s' "
490 "and RunFrom <= %d and RunTo >= %d order by CalParVer desc",
491 SftVer, run_No, run_No );
492 }
493 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
494 if ( row_no < 1 )
495 {
496 std::cout << "ERROR:error searching OffEvtFilter calibration Data in the database with: "
497 << stmt1 << std::endl;
498 return RETMySQLError;
499 }
500 int RunFrom, RunTo;
501 DatabaseRecord& records = *res[0];
502 sscanf( records["RunFrom"], "%d", &RunFrom );
503 sscanf( records["RunTo"], "%d", &RunTo );
504 cout << "@table OffEvtFilter: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
505
506 return RETOk;
507 }
508
509 Metadata::eRet Metadata::getReadCorrectedETSInfo( unsigned int serialNo, int run,
510 int FirstEvent, std::string& Version,
511 DatabaseRecordVector& res ) {
512 using namespace rdbModel;
513 eRet ret;
514 char sql[200];
515 const char* parVer = Version.c_str();
516 sprintf( sql,
517 "select Run,FinalETS,FileName,FilePath from CorrectedETS where Run= %d and "
518 "FirstEvent = %d and Version = %d",
519 run, FirstEvent, 1 );
520
521 int row_no = m_dbsvc->query( "offlinedb", sql, res );
522 string FileName;
523 FileName = ( *res[0] )["FileName"];
524 std::cout << "FileName is::::" << FileName << std::endl;
525 if ( row_no < 1 )
526 {
527 std::cout << "ERROR:error searching CorrectedETS calibration Data in the database with: "
528 << sql << std::endl;
529 return RETMySQLError;
530 }
531
532 return RETOk;
533 }
534
535 Metadata::eRet Metadata::getReadTOFInfo( unsigned int serialNo, int* runFrm, int* runTo,
536 std::string& calParVer, DatabaseRecordVector& res,
537 int runNo, std::string& sftver ) {
538 using namespace rdbModel;
539 eRet ret;
540 char stmt1[300];
541 int run_No = runNo;
542 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
543 const char* SftVer = sftver.c_str();
544
545 if ( calParVer != "default" )
546 {
547 const char* calpar = calParVer.c_str();
548 sprintf( stmt1,
549 "select "
550 "BarTofPar,EndTofPar,TofConPar,BarTof,EtfTofPar,EtfTofBunch,RunFrom,RunTo,"
551 "CalParVer,FileName,Status,"
552 "SftVer from TofCalConst where SftVer = '%s' and RunFrom "
553 "<= %d and RunTo >= %d and CalParVer = %s",
554 SftVer, run_No, run_No, calpar );
555 }
556 if ( calParVer == "default" )
557 {
558 sprintf( stmt1,
559 "select "
560 "BarTofPar,EndTofPar,TofConPar,BarTof,EtfTofPar,EtfTofBunch,RunFrom,RunTo,"
561 "CalParVer,FileName,Status,"
562 "SftVer from TofCalConst where SftVer = '%s' and RunFrom "
563 "<= %d and RunTo >= %d order by CalParVer desc",
564 SftVer, run_No, run_No );
565 }
566
567 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
568 if ( row_no < 1 )
569 {
570 std::cout << "ERROR:error searching TOF calibration Data in the database with: " << stmt1
571 << std::endl;
572 return RETMySQLError;
573 }
574 int RunFrom, RunTo;
575 DatabaseRecord& records = *res[0];
576 sscanf( records["RunFrom"], "%d", &RunFrom );
577 sscanf( records["RunTo"], "%d", &RunTo );
578 cout << "@table TofCalConst: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
579 return RETOk;
580 }
581
582 Metadata::eRet Metadata::getReadMUCInfo( unsigned int serialNo, int* runFrm, int* runTo,
583 std::string& calParVer, DatabaseRecordVector& res,
584 int runNo, std::string& sftver ) {
585 using namespace rdbModel;
586 eRet ret;
587 char stmt1[300];
588 int run_No = runNo;
589 // char* SftVer = getenv("BES_RELEASE");
590 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
591 const char* SftVer = sftver.c_str();
592
593 if ( calParVer != "default" )
594 {
595 const char* calpar = calParVer.c_str();
596 sprintf( stmt1,
597 "select "
598 "LayTree,BoxTree,StrTree,ResTree,ClsTree,RunFrom,RunTo,CalParVer,FileName,"
599 "Status,SftVer from "
600 "MucCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= "
601 "%d order by CalParVer desc",
602 SftVer, run_No, run_No );
603 }
604
605 if ( calParVer == "default" )
606 {
607 // sprintf(stmt1,"select
608 // SftVer,LayTree,BoxTree,StrTree,ResTree,ClsTree,RunFrom,RunTo,max(CalParVer),FileName
609 // from MucCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by
610 // CalParVer",SftVer,run_No,run_No);
611 sprintf( stmt1,
612 "select "
613 "LayTree,BoxTree,StrTree,ResTree,ClsTree,RunFrom,RunTo,CalParVer,FileName,"
614 "Status,SftVer from "
615 "MucCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= "
616 "%d order by CalParVer desc",
617 SftVer, run_No, run_No );
618 }
619
620 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
621 if ( row_no < 1 )
622 {
623 std::cout << "ERROR:error searching MUC calibration Data in the database with: " << stmt1
624 << std::endl;
625 return RETMySQLError;
626 }
627 int RunFrom, RunTo;
628 DatabaseRecord& records = *res[0];
629 sscanf( records["RunFrom"], "%d", &RunFrom );
630 sscanf( records["RunTo"], "%d", &RunTo );
631 cout << "@table Muc: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
632 return RETOk;
633 }
634
635 Metadata::eRet Metadata::getReadMDCInfo( unsigned int serialNo, int* runFrm, int* runTo,
636 std::string& calParVer, DatabaseRecordVector& res,
637 int runNo, std::string& sftver ) {
638 using namespace rdbModel;
639 eRet ret;
640 char stmt1[200];
641 int run_No = runNo;
642
643 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
644 const char* SftVer = sftver.c_str();
645
646 if ( calParVer != "default" )
647 {
648 const char* calpar = calParVer.c_str();
649 sprintf( stmt1,
650 "select "
651 "NewXtTrees,XtTree,QtTree,T0Tree,SdTree,R2tTrees,RunFrom,RunTo,CalParVer,"
652 "FileName,Status,SftVer "
653 "from MdcCalConst where SftVer = '%s' and RunFrom <= %d and "
654 "RunTo >= %d and CalParVer = '%s'",
655 SftVer, run_No, run_No, calpar );
656 }
657
658 if ( calParVer == "default" )
659 {
660 // sprintf(stmt1,"select
661 // NewXtTrees,XtTree,QtTree,T0Tree,SdTree,R2tTrees,RunFrom,RunTo,max(CalParVer),FileName
662 // from MdcCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by
663 // CalParVer",SftVer,run_No,run_No);}
664 sprintf( stmt1,
665 "select "
666 "NewXtTrees,XtTree,QtTree,T0Tree,SdTree,R2tTrees,RunFrom,RunTo,CalParVer,"
667 "FileName,Status,SftVer "
668 "from MdcCalConst where SftVer = '%s' and RunFrom <= %d and "
669 "RunTo >= %d order by CalParVer desc",
670 SftVer, run_No, run_No );
671 }
672
673 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
674 if ( row_no < 1 )
675 {
676 std::cout << "ERROR:error searching Mdc calibration Data in the database with: " << stmt1
677 << std::endl;
678 return RETMySQLError;
679 }
680 int RunFrom, RunTo;
681 DatabaseRecord& records = *res[0];
682 sscanf( records["RunFrom"], "%d", &RunFrom );
683 sscanf( records["RunTo"], "%d", &RunTo );
684 cout << "@table Mdc: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
685
686 return RETOk;
687 }
688
689 Metadata::eRet Metadata::getReadEMCInfo( unsigned int serialNo, int* runFrm, int* runTo,
690 std::string& calParVer, DatabaseRecordVector& res,
691 int runNo, std::string& sftver ) {
692 using namespace rdbModel;
693 eRet ret;
694 char stmt1[300];
695 int run_No = runNo;
696 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
697 const char* SftVer = sftver.c_str();
698
699 if ( calParVer != "default" )
700 {
701 const char* calpar = calParVer.c_str();
702 sprintf( stmt1,
703 "select DigiCalibConst,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from "
704 "EmcCalConst where SftVer = "
705 "'%s' and RunFrom <= %d and RunTo >= %d and CalParVer = %s",
706 SftVer, run_No, run_No, calpar );
707 }
708
709 if ( calParVer == "default" )
710 {
711 // sprintf(stmt1,"select DigiCalibConst,RunFrom,RunTo,max(CalParVer),FileName from
712 // EmcCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by
713 // CalParVer",SftVer,run_No,run_No);
714 sprintf( stmt1,
715 "select DigiCalibConst,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from "
716 "EmcCalConst where SftVer = "
717 "'%s' and RunFrom <= %d and RunTo >= %d order by CalParVer desc",
718 SftVer, run_No, run_No );
719 }
720
721 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
722 if ( row_no < 1 )
723 {
724 std::cout << "ERROR:error searching EMC calibration Data in the database with: " << stmt1
725 << std::endl;
726 return RETMySQLError;
727 }
728 int RunFrom, RunTo;
729 DatabaseRecord& records = *res[0];
730 sscanf( records["RunFrom"], "%d", &RunFrom );
731 sscanf( records["RunTo"], "%d", &RunTo );
732 cout << "@table Emc: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
733 return RETOk;
734 }
735
736 Metadata::eRet Metadata::getReadDedxInfo( unsigned int serialNo, int* runFrm, int* runTo,
737 std::string& calParVer, DatabaseRecordVector& res,
738 int runNo, std::string& sftver ) {
739 using namespace rdbModel;
740 eRet ret;
741 char stmt1[400];
742 int run_No = runNo;
743 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
744 const char* SftVer = sftver.c_str();
745
746 if ( calParVer != "default" )
747 {
748 const char* calpar = calParVer.c_str();
749 sprintf( stmt1,
750 "select "
751 "DriftDist,EntranceAng,MeanGain,GasGain,LayerGain,Resolution,WireGain,ZDep,"
752 "RunGain,RunFrom,RunTo,"
753 "CalParVer,FileName,Status,SftVer from DedxCalConst where "
754 "SftVer = '%s' and RunFrom <= %d and RunTo >= %d and CalParVer = %s",
755 SftVer, run_No, run_No, calpar );
756 }
757 if ( calParVer == "default" )
758 {
759 // sprintf(stmt1,"select
760 // DriftDist,EntranceAng,MeanGain,GasGain,LayerGain,Resolution,WireGain,ZDep,RunGain,RunFrom,RunTo,max(CalParVer),FileName
761 // from DedxCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by
762 // CalParVer",SftVer,run_No,run_No);
763 sprintf( stmt1,
764 "select "
765 "DriftDist,EntranceAng,MeanGain,GasGain,LayerGain,Resolution,WireGain,ZDep,"
766 "RunGain,RunFrom,RunTo,"
767 "CalParVer,FileName,Status,SftVer from DedxCalConst where "
768 "SftVer = '%s' and RunFrom <= %d and RunTo >= %d order by CalParVer desc",
769 SftVer, run_No, run_No );
770 }
771
772 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
773 if ( row_no < 1 )
774 {
775 std::cout << "ERROR:error searching Dedx calibration Data in the database with: "
776 << stmt1 << std::endl;
777 return RETMySQLError;
778 }
779 int RunFrom, RunTo;
780 DatabaseRecord& records = *res[0];
781 sscanf( records["RunFrom"], "%d", &RunFrom );
782 sscanf( records["RunTo"], "%d", &RunTo );
783 cout << "@table Dedx: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
784 return RETOk;
785 }
786
787 Metadata::eRet Metadata::getReadEsTimeInfo( unsigned int serialNo, int* runFrm, int* runTo,
788 std::string& calParVer,
789 DatabaseRecordVector& res, int runNo,
790 std::string& sftver ) {
791 using namespace rdbModel;
792 eRet ret;
793 char stmt1[400];
794 int run_No = runNo;
795 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
796 const char* SftVer = sftver.c_str();
797
798 if ( calParVer != "default" )
799 {
800 const char* calpar = calParVer.c_str();
801 sprintf( stmt1,
802 "select EsTimeH2,EsTimeH9,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from "
803 "EsTimeCalConst where "
804 "SftVer = '%s' and RunFrom <= %d and RunTo >= %d and CalParVer = %s",
805 SftVer, run_No, run_No, calpar );
806 }
807
808 if ( calParVer == "default" )
809 {
810 sprintf( stmt1,
811 "select EsTimeH2,EsTimeH9,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from "
812 "EsTimeCalConst where "
813 "SftVer = '%s' and RunFrom <= %d and RunTo >= %d order by "
814 "CalParVer desc",
815 SftVer, run_No, run_No );
816 }
817 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
818 if ( row_no < 1 )
819 {
820 std::cout << "ERROR:error searching EsTime calibration Data in the database with: "
821 << stmt1 << std::endl;
822 return RETMySQLError;
823 }
824 int RunFrom, RunTo;
825 DatabaseRecord& records = *res[0];
826 sscanf( records["RunFrom"], "%d", &RunFrom );
827 sscanf( records["RunTo"], "%d", &RunTo );
828 cout << "@table EsTime: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
829 return RETOk;
830 }
831
832 // get EstTof Information from mysql Database
833 Metadata::eRet Metadata::getReadEstTofInfo( unsigned int serialNo, int* runFrm, int* runTo,
834 std::string& calParVer,
835 DatabaseRecordVector& res, int runNo,
836 std::string& sftver ) {
837 using namespace rdbModel;
838 eRet ret;
839 char stmt1[200];
840 int run_No = runNo;
841 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
842 const char* SftVer = sftver.c_str();
843
844 if ( calParVer != "default" )
845 {
846 const char* calpar = calParVer.c_str();
847 sprintf( stmt1,
848 "select "
849 "BarTofPar,EndTofPar,TofConPar,BarTof,EtfTofPar,RunFrom,RunTo,CalParVer,"
850 "FileName,Status,SftVer "
851 "from EstTofCalConst where SftVer = '%s' and RunFrom <= %d and "
852 "RunTo >= %d and CalParVer = %s",
853 SftVer, run_No, run_No, calpar );
854 }
855 if ( calParVer == "default" )
856 {
857 // sprintf(stmt1,"select
858 // BarTofPar,EndTofPar,TofConPar,BarTof,RunFrom,RunTo,max(CalParVer),FileName from
859 // EstTofCalConst where SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by
860 // CalParVer",SftVer,run_No,run_No);
861 sprintf( stmt1,
862 "select "
863 "BarTofPar,EndTofPar,TofConPar,BarTof,EtfTofPar,RunFrom,RunTo,CalParVer,"
864 "FileName,Status,SftVer "
865 "from EstTofCalConst where SftVer = '%s' and RunFrom <= %d and "
866 "RunTo >= %d order by CalParVer desc",
867 SftVer, run_No, run_No );
868 }
869
870 int row_no = m_dbsvc->query( "offlinedb", stmt1, res ); // calling DatabaseSvc::query
871 if ( row_no < 1 )
872 {
873 std::cout << "ERROR:error searching EstTOF calibration Data in the database with: "
874 << stmt1 << std::endl;
875 return RETMySQLError;
876 }
877 int RunFrom, RunTo;
878 DatabaseRecord& records = *res[0];
879 sscanf( records["RunFrom"], "%d", &RunFrom );
880 sscanf( records["RunTo"], "%d", &RunTo );
881 cout << "@table EstTof: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
882 return RETOk;
883 }
884
885 Metadata::eRet Metadata::getReadTofSimInfo( unsigned int serialNo, int* runFrm, int* runTo,
886 std::string& calParVer,
887 DatabaseRecordVector& res, int runNo,
888 std::string& sftver ) {
889 using namespace rdbModel;
890 eRet ret;
891 char stmt1[200];
892 int run_No = runNo;
893 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
894 const char* SftVer = sftver.c_str();
895
896 if ( calParVer != "default" )
897 {
898 const char* calpar = calParVer.c_str();
899 sprintf( stmt1,
900 "select "
901 "BTofSim,ETofSim,SimConstants,RunFrom,RunTo,TofSimParVer,FileName,Status,"
902 "SftVer from TofSimSvc "
903 "where SftVer = '%s' and RunFrom <= %d and RunTo >= %d and "
904 "TofSimParVer = %s",
905 SftVer, run_No, run_No, calpar );
906 }
907 if ( calParVer == "default" )
908 {
909 // sprintf(stmt1,"select
910 // BTofSim,ETofSim,SimConstants,RunFrom,RunTo,max(TofSimParVer),FileName from TofSimSvc
911 // where SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by
912 // TofSimParVer",SftVer,run_No,run_No);
913 sprintf( stmt1,
914 "select "
915 "BTofSim,ETofSim,SimConstants,RunFrom,RunTo,TofSimParVer,FileName,Status,"
916 "SftVer from TofSimSvc "
917 "where SftVer = '%s' and RunFrom <= %d and RunTo >= %d order "
918 "by TofSimParVer desc",
919 SftVer, run_No, run_No );
920 }
921
922 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
923 if ( row_no < 1 )
924 {
925 std::cout << "ERROR:error searching TOFSim calibration Data in the database with: "
926 << stmt1 << std::endl;
927 return RETMySQLError;
928 }
929 int RunFrom, RunTo;
930 DatabaseRecord& records = *res[0];
931 sscanf( records["RunFrom"], "%d", &RunFrom );
932 sscanf( records["RunTo"], "%d", &RunTo );
933 cout << "@table TofSim: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
934 return RETOk;
935 }
936
937 Metadata::eRet Metadata::getReadDedxSimInfo( unsigned int serialNo, int* runFrm, int* runTo,
938 std::string& calParVer,
939 DatabaseRecordVector& res, int runNo,
940 std::string& sftver ) {
941 using namespace rdbModel;
942 eRet ret;
943 char stmt1[200];
944 int run_No = runNo;
945 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
946 const char* SftVer = sftver.c_str();
947
948 if ( calParVer != "default" )
949 {
950 const char* calpar = calParVer.c_str();
951 sprintf( stmt1,
952 "select TH1F_Col,bin,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from "
953 "DedxSim where SftVer = '%s' "
954 "and RunFrom <= %d and RunTo >= %d and CalParVer = %s",
955 SftVer, run_No, run_No, calpar );
956 }
957 if ( calParVer == "default" )
958 {
959 sprintf( stmt1,
960 "select TH1F_Col,bin,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from "
961 "DedxSim where SftVer = '%s' "
962 "and RunFrom <= %d and RunTo >= %d order by CalParVer desc",
963 SftVer, run_No, run_No );
964 }
965
966 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
967 if ( row_no < 1 )
968 {
969 std::cout << "ERROR:error searching DedxSim calibration Data in the database with: "
970 << stmt1 << std::endl;
971 return RETMySQLError;
972 }
973 int RunFrom, RunTo;
974 DatabaseRecord& records = *res[0];
975 sscanf( records["RunFrom"], "%d", &RunFrom );
976 sscanf( records["RunTo"], "%d", &RunTo );
977 cout << "@table DedxSim: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
978 return RETOk;
979 }
980
981 Metadata::eRet Metadata::getReadMdcAlignInfo( unsigned int serialNo, int* runFrm, int* runTo,
982 std::string& calParVer,
983 DatabaseRecordVector& res, int runNo,
984 std::string& sftver ) {
985 using namespace rdbModel;
986 eRet ret;
987 char stmt1[200];
988 int run_No = runNo;
989 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
990 const char* SftVer = sftver.c_str();
991
992 if ( calParVer != "default" )
993 {
994 const char* calpar = calParVer.c_str();
995 sprintf( stmt1,
996 "select "
997 "AlignEndPlate,WirePos,WireTension,RunFrom,RunTo,MdcAlignVer,AlignEPFileName,"
998 "Status,SftVer from "
999 "MdcAlignment where SftVer = '%s' and RunFrom <= %d and RunTo "
1000 ">= %d and MdcAlignVer = %s",
1001 SftVer, run_No, run_No, calpar );
1002 }
1003 if ( calParVer == "default" )
1004 {
1005 // sprintf(stmt1,"select
1006 // AlignEndPlate,WirePos,WireTension,RunFrom,RunTo,max(MdcAlignVer),AlignEPFileName
1007 // from MdcAlignment where SftVer = '%s' and RunFrom <= %d and RunTo >= %d group by
1008 // MdcAlignVer",SftVer,run_No,run_No);
1009 sprintf( stmt1,
1010 "select "
1011 "AlignEndPlate,WirePos,WireTension,RunFrom,RunTo,MdcAlignVer,AlignEPFileName,"
1012 "Status,SftVer from "
1013 "MdcAlignment where SftVer = '%s' and RunFrom <= %d and RunTo "
1014 ">= %d order by MdcAlignVer desc",
1015 SftVer, run_No, run_No );
1016 }
1017
1018 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
1019 if ( row_no < 1 )
1020 {
1021 std::cout << "ERROR:error searching MdcAlignment calibration Data in the database with: "
1022 << stmt1 << std::endl;
1023 return RETMySQLError;
1024 }
1025 int RunFrom, RunTo;
1026 DatabaseRecord& records = *res[0];
1027 sscanf( records["RunFrom"], "%d", &RunFrom );
1028 sscanf( records["RunTo"], "%d", &RunTo );
1029 cout << "@table MdcAligment: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
1030 return RETOk;
1031 }
1032
1033 Metadata::eRet Metadata::getReadMdcDataConstInfo( unsigned int serialNo, int* runFrm,
1034 int* runTo, std::string& calParVer,
1035 DatabaseRecordVector& res, int runNo,
1036 std::string& sftver ) {
1037 using namespace rdbModel;
1038 eRet ret;
1039 char stmt1[200];
1040 int run_No = runNo;
1041 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
1042 const char* SftVer = sftver.c_str();
1043
1044 if ( calParVer != "default" )
1045 {
1046 const char* calpar = calParVer.c_str();
1047 sprintf( stmt1,
1048 "select WireEff,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from "
1049 "MdcDataConst where SftVer = '%s' "
1050 "and RunFrom <= %d and RunTo >= %d and CalParVer = %s",
1051 SftVer, run_No, run_No, calpar );
1052 }
1053 if ( calParVer == "default" )
1054 {
1055 sprintf( stmt1,
1056 "select WireEff,RunFrom,RunTo,CalParVer,FileName,Status,SftVer from "
1057 "MdcDataConst where SftVer = '%s' "
1058 "and RunFrom <= %d and RunTo >= %d order by CalParVer desc",
1059 SftVer, run_No, run_No );
1060 }
1061
1062 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
1063 if ( row_no < 1 )
1064 {
1065 std::cout << "ERROR:error searching MdcDataConst Data in the database with: " << stmt1
1066 << std::endl;
1067 return RETMySQLError;
1068 }
1069 int RunFrom, RunTo;
1070 DatabaseRecord& records = *res[0];
1071 sscanf( records["RunFrom"], "%d", &RunFrom );
1072 sscanf( records["RunTo"], "%d", &RunTo );
1073 cout << "@table MdcData: RunFrom is:" << RunFrom << " RunTo is:" << RunTo << endl;
1074 return RETOk;
1075 }
1076
1077 Metadata::eRet Metadata::getReadTofQElecInfo( unsigned int serialNo, int* runFrm, int* runTo,
1078 std::string& calParVer,
1079 DatabaseRecordVector& res, int runNo,
1080 std::string& sftver ) {
1081 using namespace rdbModel;
1082 eRet ret;
1083 char stmt1[400];
1084 int run_No = runNo;
1085 if ( sftver == "default" ) sftver = getenv( "BES_RELEASE" );
1086 const char* SftVer = sftver.c_str();
1087
1088 if ( calParVer != "default" )
1089 {
1090 const char* calpar = calParVer.c_str();
1091 sprintf( stmt1,
1092 "select "
1093 "BarBoardNum,EndBoardNum,QELecBarParEast,QELecBarParWest,QELecEndPar,"
1094 "SimQELecBarParEast,"
1095 "SimQELecBarParWest,SimQELecEndPar,RunFrom,RunTo,CalParVer,FileName,Status,"
1096 "SftVer from TofQELec where SftVer = '%s' and RunFrom <= %d and RunTo >= %d "
1097 "and CalParVer = %s",
1098 SftVer, run_No, run_No, calpar );
1099 }
1100 if ( calParVer == "default" )
1101 {
1102 sprintf( stmt1,
1103 "select "
1104 "BarBoardNum,EndBoardNum,QELecBarParEast,QELecBarParWest,QELecEndPar,"
1105 "SimQELecBarParEast,"
1106 "SimQELecBarParWest,SimQELecEndPar,RunFrom,RunTo,CalParVer,FileName,Status,"
1107 "SftVer from TofQELec where SftVer = '%s' and RunFrom <= %d and RunTo >= %d "
1108 "order by CalParVer desc",
1109 SftVer, run_No, run_No );
1110 }
1111 int row_no = m_dbsvc->query( "offlinedb", stmt1, res );
1112 if ( row_no < 1 )
1113 {
1114 std::cout << "ERROR:error searching TofQElec calibration Data in the database with: "
1115 << stmt1 << std::endl;
1116 return RETMySQLError;
1117 }
1118 int RunFrom, RunTo;
1119 DatabaseRecord& records = *res[0];
1120 sscanf( records["RunFrom"], "%d", &RunFrom );
1121 sscanf( records["RunTo"], "%d", &RunTo );
1122 cout << "Read from DB TofQElec: RunFrom " << RunFrom << " RunTo= " << RunTo << endl;
1123 std::cout << "metadata ok" << std::endl;
1124
1125 return RETOk;
1126 }
1127
1128 /*
1129
1130 | Field | Type | Null | Key | Default | How set |
1131 +-------------+--------------------+------+-----+---------+------------------+
1132 | ser_no | mediumint(9) | | PRI | NULL | auto_increment |
1133 | instrument | varchar(16) | | | | [openRecord] |
1134 | calib_type | varchar(20) | | | | [openRecord |
1135 | data_fmt | varchar(10) | | | | [openRecord] |
1136 | data_size | int(11) | YES | | NULL | [optional] |
1137 | vstart | datetime | YES | | NULL |[addValidInterval]|
1138 | vend | datetime | YES | | NULL |[addValidInterval]|
1139 | enter_time | timestamp(14) | YES | | NULL | automatic |
1140 | fmt_version | varchar(12) | YES | | NULL | [openRecord] |
1141 | completion | enum('OK','INC','ABORT')
1142 | YES | MUL | NULL | [openRecord] |
1143 | proc_level | enum('PROD','TEST','DEV', 'SUPSED')
1144 | | | TEST | [openRecord] |
1145 | creator | varchar(255) | YES | | NULL | [addCreator] |
1146 | uid | varchar(12) | | | |[insertRecord/
1147 addUser] |
1148 | data_ident | varchar(255) | | | | [openRecord] |
1149 | input_desc | varchar(255) | YES | | NULL |[addInputDesc] |
1150 | notes | varchar(255) | YES | | NULL | [addNotes] |
1151 +-------------+--------------------+------+-----+---------+------------------+
1152
1153 */
1154
1155 Metadata::eRet Metadata::doSelect( std::vector<rdbModel::Assertion::Operator*>& conditions,
1156 rdbModel::StringVector& orderBy, unsigned*& ser ) {
1157 using namespace rdbModel;
1158 *ser = 0;
1159
1160 StringVector colNames( 1 );
1161 colNames[0] = "ser_no";
1162
1163 // make the combined operator
1164 Assertion::Operator andOp( OPTYPEand, conditions, true );
1165
1166 // Following creates an assertion such that creator (us) continues
1167 // to own the associated operator.
1168 Assertion whereClause( &andOp, 0, true );
1169 ResultHandle* results = 0;
1170
1171 if ( results ) { delete results; }
1172
1173 try
1174 { // make the query
1175 results = m_readCxt->select( m_table, colNames, orderBy, &whereClause );
1176
1177 } catch ( RdbException ex )
1178 { std::cout << ex.getMsg(); }
1179
1180 if ( !results )
1181 { // Error. Should have ResultHandle even if 0 rows.
1182 std::cout << "no results" << std::endl;
1183 return RETMySQLError;
1184 }
1185
1186 std::cout << "There are results" << std::endl;
1187 // handle result.
1188 if ( results->getNRows() == 0 )
1189 {
1190 conditions.pop_back();
1191 std::cout << "no results" << std::endl;
1192 return RETBadValue;
1193 }
1194 else
1195 {
1196 std::vector<std::string> fields;
1197 results->getRow( fields );
1198
1199 if ( results ) { delete results; }
1200 *ser = facilities::Util::stringToInt( fields[0] );
1201 return RETOk;
1202 }
1203 }
1204
1205 int Metadata::registerCalib( const std::string& inst, const std::string& flavor,
1206 const std::string& calib_type, const std::string& data_ident,
1207 const std::string& data_fmt, unsigned int& runfrm,
1208 unsigned int& runto, const std::string& input_desc,
1209 const std::string& notes, const std::string& proc_level,
1210 const std::string& locale, const std::string& fmt_version,
1211 const std::string& completion ) {
1212
1213 using namespace rdbModel;
1214
1215 eRet ret;
1216
1217 if ( !m_writeCxt )
1218 {
1219 connectWrite( ret );
1220 if ( ret != RETOk ) return 0; // we or connectWrite should throw exception
1221 }
1222 StringVector cols;
1223 StringVector vals;
1224 StringVector nullCols;
1225
1226 cols.reserve( 24 );
1227 vals.reserve( 24 );
1228 nullCols.reserve( 16 );
1229
1230 if ( inst.size() * calib_type.size() * flavor.size() * data_fmt.size() *
1231 data_ident.size() * proc_level.size() * completion.size() * locale.size() ==
1232 0 )
1233 { // something is null that shouldn't be
1234 return 0; // should perhaps throw exception
1235 }
1236 cols.push_back( "calib_type" );
1237 vals.push_back( calib_type );
1238 // cols.push_back("flavor"); vals.push_back(flavor);
1239 cols.push_back( "data_fmt" );
1240 vals.push_back( data_fmt );
1241 cols.push_back( "data_ident" );
1242 vals.push_back( data_ident );
1243 cols.push_back( "status" );
1244 vals.push_back( completion );
1245 std::string s_runfrm, s_runto;
1246 facilities::Util::itoa( runfrm, s_runfrm );
1247 facilities::Util::itoa( runto, s_runto );
1248 cols.push_back( "RunFrom" );
1249 vals.push_back( s_runfrm );
1250 cols.push_back( "RunTo" );
1251 vals.push_back( s_runto );
1252
1253 // These, however, may be null
1254 if ( input_desc.size() > 0 )
1255 {
1256 cols.push_back( "input_desc" );
1257 vals.push_back( input_desc );
1258 }
1259 else nullCols.push_back( "input_desc" );
1260
1261 if ( notes.size() > 0 )
1262 {
1263 cols.push_back( "notes" );
1264 vals.push_back( notes );
1265 }
1266 else nullCols.push_back( "notes" );
1267
1268 if ( fmt_version.size() > 0 )
1269 {
1270 cols.push_back( "fmt_version" );
1271 vals.push_back( fmt_version );
1272 }
1273
1274 // The service -- that's us -- is responsible for creator, uid, enter_time
1275 cols.push_back( "creator" );
1276 vals.push_back( "Metadata::registerCalib" );
1277 std::string uid;
1278 fetchUser( uid );
1279 cols.push_back( "uid" );
1280 vals.push_back( uid );
1281 facilities::Timestamp curTime;
1282 cols.push_back( "enter_time" );
1283 vals.push_back( curTime.getString() );
1284 // update_time is set automatically by MySQL, but MySQL uses
1285 // local timezone rather than gmt, so we have set it explicitly
1286 cols.push_back( "update_time" );
1287 vals.push_back( curTime.getString() );
1288
1289 if ( m_rdb )
1290 {
1291 bool ok = checkValues( cols, vals );
1292 if ( ok ) checkNulls( nullCols );
1293 if ( !ok ) return 0;
1294 }
1295
1296 // ser_no gets set automatically by MySQL
1297 int ser_no;
1298 if ( !( m_writeCxt->insertRow( m_table, cols, vals, &ser_no, &nullCols ) ) ) { return 0; }
1299 else
1300 {
1301 adjustVend( ser_no );
1302 return ser_no;
1303 }
1304 }
1305
1306 Metadata::eRet Metadata::compareSchema( rdbModel::Connection* conn,
1307 const std::string& schema ) {
1308 using namespace rdbModel;
1309
1310 if ( m_man )
1311 { // already did this
1312 return ( m_match ) ? RETOk : RETNoSchemaMatch;
1313 }
1314 m_man = rdbModel::Manager::getManager();
1315
1316 m_man->setBuilder( new rdbModel::XercesBuilder );
1317 m_man->setInputSource( schema );
1318
1319 // Maybe first check if file exists? E.g., try opening for read
1320
1321 // good errcode is 0
1322 int errcode = m_man->build();
1323
1324 if ( errcode )
1325 {
1326 std::cerr << "Error in database description file " << schema << std::endl;
1327 std::cerr << "Parse failed with error " << errcode << std::endl;
1328 return RETBadCnfFile;
1329 }
1330 m_rdb = m_man->getRdb();
1331
1332 rdbModel::MATCH match = conn->matchSchema( m_rdb, false );
1333
1334 switch ( match )
1335 {
1336 case rdbModel::MATCHequivalent:
1337 case rdbModel::MATCHcompatible: m_match = true; return RETOk;
1338 case rdbModel::MATCHfail:
1339 std::cout << "XML schema and MySQL database are NOT compatible" << std::endl;
1340 return RETBadCnfFile;
1341 case rdbModel::MATCHnoConnection:
1342 std::cout << "Connection failed while attempting match" << std::endl;
1343 return RETNoConnect;
1344 }
1345 return RETBadValue;
1346 }
1347
1348 bool Metadata::checkValues( const rdbModel::StringVector& cols,
1349 const rdbModel::StringVector& vals ) const {
1350 unsigned nCol = cols.size();
1351 rdbModel::Table* table = m_rdb->getTable( m_table );
1352
1353 for ( unsigned iCol = 0; iCol < nCol; iCol++ )
1354 {
1355 rdbModel::Column* col = table->getColumnByName( cols[iCol] );
1356 if ( !col->okValue( vals[iCol] ) )
1357 {
1358 std::cerr << "Value " << vals[iCol] << " not allowed for column " << cols[iCol]
1359 << " in table " << m_table << std::endl;
1360 return false;
1361 }
1362 }
1363 return true;
1364 }
1365
1366 bool Metadata::checkNulls( const rdbModel::StringVector& cols ) const {
1367 unsigned nCol = cols.size();
1368 rdbModel::Table* table = m_rdb->getTable( m_table );
1369
1370 for ( unsigned iCol = 0; iCol < nCol; iCol++ )
1371 {
1372 rdbModel::Column* col = table->getColumnByName( cols[iCol] );
1373 if ( !col->nullAllowed() )
1374 {
1375 std::cerr << "Column " << cols[iCol] << " in table " << m_table << " is not nullable"
1376 << std::endl;
1377 return false;
1378 }
1379 }
1380 return true;
1381 }
1382
1383 unsigned Metadata::adjustVend( int newSer ) {
1384 using namespace rdbModel;
1385
1386 StringVector getCols;
1387 StringVector orderBy;
1388
1389 orderBy.clear();
1390 getCols.reserve( 7 );
1391
1392 std::string serString;
1393 facilities::Util::itoa( newSer, serString );
1394
1395 getCols.push_back( "flavor" );
1396 getCols.push_back( "calib_type" );
1397 getCols.push_back( "completion" );
1398
1399 ResultHandle* results = 0;
1400 eRet err;
1401 Assertion* where = 0;
1402 try
1403 {
1404 if ( !m_writeCxt )
1405 {
1406 if ( !connectWrite( err ) ) return 0;
1407 }
1408
1409 Assertion::Operator* serOp = new Assertion::Operator( OPTYPEequal, "ser_no", serString,
1410 FIELDTYPEold, FIELDTYPElit );
1411 // false, true);
1412
1413 where = new Assertion( serOp );
1414
1415 // Fetch information for new row: vstart, flavor, completion,
1416 // proc_level, calib_type, flavor
1417 results = m_writeCxt->select( m_table, getCols, orderBy, where );
1418 // results = m_writeCxt->select("metadata_v0", getCols, orderBy, where);
1419 delete where;
1420 where = 0;
1421 } catch ( RdbException ex )
1422 {
1423 std::cout << ex.getMsg();
1424 delete where; // return heap memory
1425 return 0;
1426 }
1427 if ( !results )
1428 { // This is an error. Should be non-null even if no rows
1429 std::cout << "MySQL failure in SELECT" << std::endl;
1430 return 0; // nothing to fix
1431 }
1432 if ( results->getNRows() != 1 )
1433 { // also a problem
1434 std::cout << "Look-up of serial# " << serString << " failed" << std::endl;
1435 return 0;
1436 }
1437 std::vector<std::string> fields;
1438 results->getRow( fields );
1439 if ( fields[2] != "OK" ) return 0; // don't bother fixing in this case
1440
1441 // Now do an update on rows satisfying
1442 // ((flavor="f") && (calib_type = "c") && (completion= "OK") &&
1443 // (instrument = "i") && (proc_level = "p") &&
1444 // (vstart < "new-start" (vend > "new-vstart") );
1445 std::vector<Assertion::Operator*> conditions;
1446 conditions.reserve( 7 );
1447 for ( unsigned ix = 0; ix < 5; ix++ )
1448 {
1449 conditions.push_back( new Assertion::Operator( OPTYPEequal, getCols[ix], fields[ix],
1450 FIELDTYPEold, FIELDTYPElit ) );
1451 // false, true));
1452 }
1453 conditions.push_back( new Assertion::Operator( OPTYPElessThan, "vstart", fields[5],
1454 FIELDTYPEold, FIELDTYPElit ) );
1455 // false, true));
1456 conditions.push_back( new Assertion::Operator( OPTYPEgreaterThan, "vend", fields[5],
1457 FIELDTYPEold, FIELDTYPElit ) );
1458 // false, true));
1459
1460 Assertion::Operator* andOp = new Assertion::Operator( OPTYPEand, conditions );
1461 where = new Assertion( andOp );
1462
1463 StringVector toUpdate;
1464 toUpdate.push_back( "vend" );
1465 StringVector newVal;
1466 newVal.push_back( fields[5] );
1467 // also update update_time. If we leave it to MySQL, won't be GMT
1468 facilities::Timestamp curTime;
1469 toUpdate.push_back( "update_time" );
1470 newVal.push_back( curTime.getString() );
1471
1472 unsigned nModified = m_writeCxt->update( m_table, toUpdate, newVal, where );
1473 delete where;
1474 return nModified;
1475 }
1476
1477} // namespace calibUtil
StringVector
std::vector< std::string > StringVector
Simple algorithm to test functioning of "the other" TDS.
Definition CheckMySQL.h:48
sprintf
sprintf(cut, "kal_costheta0_em>-0.93&&kal_costheta0_em<0.93&&kal_pxy0_em>=0.05+%d*0.1&&kal_" "pxy0_em<0.15+%d*0.1&&NGch>=2", j, j)
SftVer
char * SftVer
Definition DQA_TO_DB.cxx:19
runNo
int runNo
Definition DQA_TO_DB.cxx:13
calibUtil::Metadata::getReadMdcDataConstInfo
eRet getReadMdcDataConstInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:1033
calibUtil::Metadata::checkValues
bool checkValues(const rdbModel::StringVector &cols, const rdbModel::StringVector &vals) const
Definition Metadata.cxx:1348
calibUtil::Metadata::getReadEsTimeInfo
eRet getReadEsTimeInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:787
calibUtil::Metadata::checkNulls
bool checkNulls(const rdbModel::StringVector &cols) const
Definition Metadata.cxx:1366
calibUtil::Metadata::getReadInjSigTimeInfo
eRet getReadInjSigTimeInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:419
calibUtil::Metadata::findBest
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")
Definition Metadata.cxx:252
calibUtil::Metadata::getReadTOFInfo
eRet getReadTOFInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:535
calibUtil::Metadata::getReadInfo
eRet getReadInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &dataFmt, std::string &dataIdent)
Definition Metadata.cxx:316
calibUtil::Metadata::connectRead
bool connectRead(eRet &err)
Definition Metadata.cxx:114
calibUtil::Metadata::getReadDedxSimInfo
eRet getReadDedxSimInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:937
calibUtil::Metadata::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 Metadata.cxx:38
calibUtil::Metadata::getReadMUCInfo
eRet getReadMUCInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:582
calibUtil::Metadata::getReadEstTofInfo
eRet getReadEstTofInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:833
calibUtil::Metadata::getReadTofSimInfo
eRet getReadTofSimInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:885
calibUtil::Metadata::getReadOffEvtFilterInfo
eRet getReadOffEvtFilterInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:464
calibUtil::Metadata::getReadDedxInfo
eRet getReadDedxInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:736
calibUtil::Metadata::getReadInjSigIntervalInfo
eRet getReadInjSigIntervalInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:373
calibUtil::Metadata::getReadCorrectedETSInfo
eRet getReadCorrectedETSInfo(unsigned int serialNo, int runNo, int FirstEvent, std::string &Version, DatabaseRecordVector &res)
Definition Metadata.cxx:509
calibUtil::Metadata::getReadMdcAlignInfo
eRet getReadMdcAlignInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:981
calibUtil::Metadata::registerCalib
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")
Definition Metadata.cxx:1205
calibUtil::Metadata::getReadMDCInfo
eRet getReadMDCInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:635
calibUtil::Metadata::getReadTofQElecInfo
eRet getReadTofQElecInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:1077
calibUtil::Metadata::findSoonAfter
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")
Definition Metadata.cxx:187
calibUtil::Metadata::getReadEMCInfo
eRet getReadEMCInfo(unsigned int serialNo, int *runFrm, int *runTo, std::string &calParVer, DatabaseRecordVector &res, int runNo, std::string &sftver)
Definition Metadata.cxx:689
facilities::Timestamp::getString
std::string getString() const
Return string representation of time, not including nanoseconds;.
Definition Timestamp.cxx:87
facilities::Util::expandEnvVar
static int expandEnvVar(std::string *toExpand, const std::string &openDel=std::string("$("), const std::string &closeDel=std::string(")"))
facilities::Util::atoi
static int atoi(const std::string &InStr)
converts an std::string to an integer
Definition Calibration/facilities/src/Util.cxx:83
facilities::Util::stringToInt
static int stringToInt(const std::string &InStr)
Definition Calibration/facilities/src/Util.cxx:113
facilities::Util::itoa
static const char * itoa(int val, std::string &outStr)
Definition Calibration/facilities/src/Util.cxx:56
rdbModel::Column::nullAllowed
bool nullAllowed() const
Returns true if column may take on value NULL.
Definition Calibration/rdbModel/include/rdbModel/Tables/Column.h:78
rdbModel::Column::okValue
bool okValue(const std::string &val, bool set=true) const
Definition Column.cxx:18
rdbModel::Connection::select
virtual ResultHandle * select(const std::string &tableName, const StringVector &getCols, const StringVector &orderCols, const Assertion *where=0, int rowLimit=0, int rowOffset=0)=0
rdbModel::Connection::matchSchema
virtual MATCH matchSchema(Rdb *rdb, bool matchDbName=true)=0
rdbModel::Connection::open
virtual bool open(const std::string &host, const std::string &userid, const std::string &password, const std::string &dbName)=0
rdbModel::Manager::setBuilder
void setBuilder(Builder *b)
Definition Manager.cxx:35
rdbModel::Manager::getManager
static Manager * getManager()
Definition Manager.cxx:24
rdbModel::ResultHandle::getRow
virtual bool getRow(std::vector< std::string > &fields, unsigned int i=0, bool clear=true)=0
rdbModel::ResultHandle::getNRows
virtual unsigned int getNRows() const =0
Return number of rows in results.
rdbModel::Table::getColumnByName
Column * getColumnByName(const std::string &name) const
Definition Table.cxx:67
ix
#define ix(i)
Definition minoreval.cpp:424
calibUtil
Module implements methods for clients to get generic services.
Definition Calibration/CalibSvc/CalibDataSvc/include/CalibDataSvc/ICalibMetaCnvSvc.h:23