STEER/TFndDB.cxx

// @(#)fROOT/STEER:$Name:  $:$Id: TFndDB.cxx,v 1.10 2007/09/24 07:32:41 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2006/07/05

//                                                                          //
//                               TFndFeeDB                                  //
//                                                                          //
// Interface to the FINUDA official database.                               //
//                                                                          //
//                                                                          //
//  The  fDBServ server-interface is used in order to establish the         //
//   connection with the remote-or-local mysql database                     //
//                                                                          //
//  The complete content of the whole database can be loaded by calling the //
//  "LoadAllInfo" method: in this case the whole content of the database is //
//  fetched and stored into TTreeSQL objects (fSqlTree[]).                  //
//  fSqlTree[] are available by calling "GetSqlTree(<EFndDbTables>)"        //
//                                                                          //
//  On the other hand, the selected information (according to the run-time) //
//  is stored into data-members by the "FetchRunInfo" method.               //
//  all these data-members are available ("Get<detector><spec>" methods)    //
//                                                                          //
//  Fetching the complete content of every table allows to manage every     //
//  table within this class.                                                //
//  The memory used to store fSqlTree[] can be released by calling the      //
//  "UnloadAllInfo"
//  after having called  DisconnectFromHost() only the selected information //
//  will be available.                                                      //
//                                                                          //
//  While filling data-members with the selected info fCurRow is used.      //
//                                                                          //

#include "TThread.h"
#include "TSQLTableInfo.h"
#include "TSQLColumnInfo.h"

#include "TFndRun.h"

#include "TFndDB.h"

ClassImp(TFndDB)

//_______________________________________
TFndDB::TFndDB():
  fSqlTree()
{

}

//_______________________________________
TFndDB::~TFndDB(){

  UnloadAllInfo(); // release used memory (if needed)
  DisconnectFromHost(); // prevent from user mistakes

  delete fCurRow;
  delete fCurRes;
  delete fDBServ;
}

//_______________________________________
Int_t TFndDB::ConnectToHost(const TString &server,TString user,TString passwd,Int_t timeout,Int_t n_trials){
  // - timeout is the connection timeout in seconds
  // - n_trials is the number of times the connection will be tried
  //   before exiting with error (return -1)
  //
  // return value:
  //              0: ok
  //             -1: no connection to DB host (or DB not available)
  
  DisconnectFromHost(); // do not allow the user to open more than one connection at a time
  fIsThere = kFALSE;
  TString host_str;
  host_str.Form("mysql://%s/?timeout=%d:%s",server.Data(),timeout,gSystem->Getenv("MYSQL_TCP_PORT"));
  // TSQLServer::Connect("mysql://host.domain/test?timeout=10","user","passwd")
  
  for(Int_t nt=1;nt<=n_trials;nt++){
    fDBServ = (TSQLServer *) TSQLServer::Connect(host_str, user, passwd);
    if(fDBServ) break;
    else Warning("ConnectToHost","Connection to DB failed (timeout=%d): retrying (%d)",timeout,nt);
  }
  if(!fDBServ){
    Error("ConnectToHost","Database not available after %d trials: check connection to DB-host",n_trials);
    return -1;
  }
  return 0;
}

//_______________________________________
void TFndDB::DisconnectFromHost(){
  // by calling this method the memory used for fetching
  // the complete content of all tables is automatically released:
  // all fSqlTree[] are deleted.
 
  if(fDBServ) if(fDBServ->IsConnected()) fDBServ->Close();
  delete fDBServ; fDBServ = 0;
}

//_______________________________________
Int_t TFndDB::UnloadAllInfo(){
  

  for(Int_t i=0;i<K_N_DbTables;i++){
    delete fSqlTree[i];
    fSqlTree[i] = 0;
  }

}

//_______________________________________
TSQLResult* TFndDB::Query(TString DB_name, TString QueryStr,Int_t print_mode){
  // return a TSQLResult pointer withe the query result
  //

  if(!fDBServ){
    Warning("Query","can not perform any query: DB server not available");
    return 0;
  }

  fDBServ->SelectDataBase(DB_name);
  fCurRes = (TSQLResult *) fDBServ->Query(QueryStr);
  if(!fCurRes){
    Error("Query","Failure while querying from DB (\"%s\")",DB_name.Data());
    return 0;
  }

  if(print_mode == (Int_t )Q_SILENT) return fCurRes;
  
  for(Int_t r=0;r<fCurRes->GetRowCount();r++){
    fCurRow = (TSQLRow *) fCurRes->Next();
    PrintCurRow(r,print_mode);
  }

  return fCurRes;
}

//_______________________________________
void TFndDB::PrintCurRow(Int_t row_num,Int_t print_mode){
  //  { Q_SILENT = 0, Q_GENINFO, Q_COMPACT, Q_DETAILED, Q_MYSQL_STYLE };
  
  Int_t conv_type = -1;

  TString cur_row_str = "";
  for(Int_t f=0;f<fCurRes->GetFieldCount();f++){
    cur_row_str += fCurRes->GetFieldName(f);
    //    TSQLColumnInfo cinf = TSQLColumnInfo(fCurRow->GetField(f));
    //    Printf("Type[%d]: \"%d\"",f,cinf.GetSQLType() );
    //    switch(conv_type){
    //    case (Int_t) FINTYPE_INT:
    cur_row_str += (Int_t)TString(fCurRow->GetField(f)).Atoi();
    //       break;
    //     case (Int_t) FINTYPE_FLOAT:
    //    cur_row_str += (Float_t)TString(fCurRow->GetField(f)).Atof();
    //       break;
    //     case (Int_t) FINTYPE_CHAR:
    //       cur_row_str += (Char_t *)TString(fCurRow->GetField(f)).Data();
    //       break;
    
    //    }
    cur_row_str += "; ";
  }
  cur_row_str += ".";
  Printf("row %d: %s",row_num,cur_row_str.Data());

}

//_______________________________________
Int_t TFndDB::FetchRunInfo(Bool_t verbose,UInt_t run_time,Bool_t also_calib){
  // The selected information (according to the run-time)
  // is stored into standard arrays (saved to HDT root-file)
  //
  // If fndrun is not available or the run-time
  // is not defined, then:
  //           - TofDB2 is selected by default
  //           - No selection will be performed on tables content
  //           - fIsThere = kFALSE;
  //
  // The run-time can be passed as argument directly to this method:
  //  in this case fndrun->GetRunTime will not be considered
  //  (this is for people who needs to inspect the database content)
  //
  // return value:
  //               0: fetching performed succesfully
  //              -1: no interface loaded
  //              -2: run-time not defined (no selected information)

  if(!fDBServ){
    Warning("FetchRunInfo","No interface to DB server loaded");
    return -1;
  } 
  
  // Get run time from argument or update local reference to the time of the run
  //  then select the correct table for TOF
  UInt_t RunTime = run_time;
  if(RunTime == 0){
    if(fndrun) RunTime = fndrun->GetRunTime();
    else {
      Error("FetchRunInfo","fndrun not defined: RunTime will not be available");
      return -2;
    }
  }
  
  //   if(RunTime == 0){
  //     Error("FetchRunInfo","RunTime not defined: selected information not available");
  //     return -2;
  //   }
  
  // FETCH HERE !!!
  Int_t fetch_err = 0;
 
  fetch_err += FetchTofRunInfo(verbose,RunTime);
  fetch_err += FetchSilRunInfo(verbose,RunTime);
  fetch_err += FetchLmdRunInfo(verbose,RunTime);
  fetch_err += FetchStbRunInfo(verbose,RunTime);

  if(also_calib){
    // --- CALIBRATION
    fetch_err += FetchTofCalibInfo(verbose);
    fetch_err += FetchLmdCalibInfo(verbose);
    fetch_err += FetchStbCalibInfo(verbose);
  }
  

  fIsThere = kTRUE;
  return fetch_err;
}

//_______________________________________
Int_t TFndDB::FetchTofRunInfo(Bool_t verbose,const Int_t &run_time){
  // return value:
  //              0: ok
  //             -1: failure while querying
  //
  //  sprintf(qry,"SELECT w,ap,ae,tp,te,tm,q0p,q0e,q1p,q1e,t0p,t0e,t0m,cnp,cne,cnm FROM fee %s ORDER BY w",where);
  //  sprintf(qry,"SELECT w,A,Z,VER,offtime FROM offset %s AND VER= %d ORDER BY w",where,offsetver_.ofstver);
  
  Int_t rows = 0; // used for fetching rows
  
  // SELECT ACCORDING TO THE RUN-TIME
  TString TofDB_str = "TofDB";
  if(run_time > FROOT::DTak_2006_SftwStartTime) TofDB_str = "TofDB2";
  if(verbose) Printf("TFndDB::FetchTofRunInfo ---> Selected DB for TOF is \"%s\"",TofDB_str.Data());
  
  
  fDBServ->SelectDataBase(TofDB_str);
  TString QueryStr;
  
  // --- FEE info
  QueryStr.Form("select w, ap, ae, tp, te, tm from fee where A< %d and Z> %d order by w",run_time,run_time);
  Printf("Query string: \"%s\"",QueryStr.Data());
  fCurRes = (TSQLResult *) fDBServ->Query(QueryStr);
  
  if(!fCurRes){
    Error("FetchTofRunInfo","Failure while querying from table \"fee\" (\"%s\")",TofDB_str.Data());
    return -1;
  }

  if(verbose){
    Printf("Number of selected rows: %d",fCurRes->GetRowCount());
    Printf("Number of fields / row : %d",fCurRes->GetFieldCount());
  }
  //
  fCurRow = 0;
  
  Int_t imodule_adc = 0;
  Int_t ichannel_adc = 0;
  Int_t imodule_tdc = 0;
  Int_t ichannel_tdc = 0;
  Int_t imodule_mt = 0;
  Int_t ichannel_mt = 0;

  // Fetch row-by-row (use ROOT iterator "Next()")
  for(Int_t r=0;r<fCurRes->GetRowCount();r++){
    fCurRow = (TSQLRow *) fCurRes->Next();
    if(verbose) PrintCurRow(r,(Int_t)Q_COMPACT);
    // fetch field-by-field from current raw
    Int_t islab = TString(fCurRow->GetField(0)).Atoi();

  }
  fCurRes = 0;  
  return 0;
}

//_______________________________________
Int_t TFndDB::FetchSilRunInfo(Bool_t verbose,Int_t run_time){

}

//_______________________________________
Int_t TFndDB::FetchLmdRunInfo(Bool_t verbose,Int_t run_time){

}

//_______________________________________
Int_t TFndDB::FetchStbRunInfo(Bool_t verbose,Int_t run_time){

}

//_______________________________________
Int_t TFndDB::LoadAllInfo(Bool_t verbose,TString TofDB_str){
  // The complete (not selected) information
  // is stored (but not saved) into fSqlTree[]
  //
  // Concernong the TOF database:
  //   TofDB2 is the dafault:
  //   if you want to load TofDB you must pass "TofDB" as second argument
  //
  // return value:
  //               0: fetching and loading performed succesfully
  //              -1: no interface loaded
  //              -2: Error while getting  (no selected information)

  if(!fDBServ){
    Warning("LoadAllInfo","No interface to DB server loaded");
    return -1;
  } 

  // (FETCH and then CHECK)
  if(verbose) Printf("TFndDB::LoadAllInfo ---> Selected DB for TOF is \"%s\"",TofDB_str.Data());
  delete fSqlTree[DBTAB_TOF_FEE];    fSqlTree[DBTAB_TOF_FEE]    =  new  TTreeSQL(fDBServ,TofDB_str,"fee");
  delete fSqlTree[DBTAB_TOF_CALIB];  fSqlTree[DBTAB_TOF_CALIB]  =  new  TTreeSQL(fDBServ,TofDB_str,"calib");
  delete fSqlTree[DBTAB_TOF_OFFSET]; fSqlTree[DBTAB_TOF_OFFSET] =  new  TTreeSQL(fDBServ,TofDB_str,"offset");
  delete fSqlTree[DBTAB_SIL_FEE];    fSqlTree[DBTAB_SIL_FEE]    =  new  TTreeSQL(fDBServ,"SilDB","fee");
  delete fSqlTree[DBTAB_LMD_FEE];    fSqlTree[DBTAB_LMD_FEE]    =  new  TTreeSQL(fDBServ,"LmdDB","fee");
  delete fSqlTree[DBTAB_STB_FEE];    fSqlTree[DBTAB_STB_FEE]    =  new  TTreeSQL(fDBServ,"StbDB","fee");
  
  Bool_t AllLoaded = kTRUE;
  for(Int_t i=0;i<K_N_DbTables;i++){
    if(i!=DBTAB_TOF_CALIB) AllLoaded = AllLoaded && ((Bool_t)(fSqlTree[i]->GetEntries()));
    if(verbose) Printf("             entries of table[%d] (see TFndDB::EFndDbTables): %d",i,fSqlTree[i]->GetEntries());
  }
  if(TofDB_str.CompareTo("TofDB2") ==0) AllLoaded && ((Bool_t)(fSqlTree[DBTAB_TOF_CALIB]->GetEntries()));
  
  if(!AllLoaded){
    Error("LoadAllInfo","Errors while fetching information from database");
    return -2;
  }
  return 0;
}


//_______________________________________
Int_t TFndDB::FetchTofCalibInfo(const Bool_t &verbose){

  if(verbose) Printf("TFndDB::FetchTofCalibInfo ---> entering method");

  // ---
  if(verbose) Printf("TFndDB::FetchTofCalibInfo ---> exiting method");
  return 0;
}


//_______________________________________
Int_t TFndDB::FetchLmdCalibInfo(const Bool_t &verbose){

  if(verbose) Printf("TFndDB::FetchLmdCalibInfo ---> entering method");

  // ---
  if(verbose) Printf("TFndDB::FetchLmdCalibInfo ---> exiting method");
  return 0;  
}

//_______________________________________
Int_t TFndDB::FetchStbCalibInfo(const Bool_t &verbose){
  
  if(verbose) Printf("TFndDB::FetchStbCalibInfo ---> entering method");

  // ---
  if(verbose) Printf("TFndDB::FetchStbCalibInfo ---> exiting method");
  return 0;
}

---