/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Calibration/calibUtil/calibUtil-00-00-43/calibUtil/Metadata.h

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/calibUtil/calibUtil/Metadata.h,v 1.20 2012/01/05 03:53:49 zhangy Exp $
#ifndef CALIBUTIL_METADATA_H
#define CALIBUTIL_METADATA_H

#include "facilities/Timestamp.h"
#include "rdbModel/Db/Connection.h"
#include "rdbModel/Tables/Assertion.h"
//#include "DatabaseSvc/DatabaseRecord.h"
#include "DatabaseSvc/IDatabaseSvc.h"

namespace rdbModel {
  class Rdb;
  class Manager;
}

namespace calibUtil {
  class Metadata {
  public:
    enum eRet {
      RETOk = 0,
      RETBadCnfFile = 1,
      RETBadHost = 2,
      RETNoConnect = 3,
      RETWrongState = 4,
      RETBadValue = 5,
      RETMySQLError = 6,
      RETNoSchemaMatch = 7
    };
    enum eLevel {
      LEVELProd = 1,
      LEVELDev  = 2,
      LEVELTest = 4,
      LEVELSuperseded = 8
    };


    /* Someday provide option of reading in description of table. In case
       it is used, can check that it matches dbs we're connected to, and
       can check column values.
    */
      
    Metadata(const std::string& host="bes3db2.ihep.ac.cn",
             const std::string& table="*",
             const std::string& dbName="calib");

    ~Metadata();

/*maqm    eRet findBest(unsigned int *ser,
                  const std::string& calibType, 
                  const facilities::Timestamp& timestamp,
                  unsigned int levelMask, 
                  const std::string& instrument,
                  const std::string& flavor="VANILLA");
maqm*/
     //maqm modify
     eRet findBest(unsigned int *ser,
                   const std::string& calibType,
                   const std::string& sft_ver,
                   const std::string& cal_ver,
                   const std::string& cal_par,
                   const std::string& rec_alg,
                   const std::string& rec_par,
                   const std::string& machine,
                   const std::string& flavor="VANILLA");
     
    eRet findSoonAfter(unsigned int *ser,
                       const std::string& calibType, 
                       const std::string& sft_ver,
                       const std::string& cal_ver,
                       const std::string& cal_par,
                       const std::string& rec_alg,
                       const std::string& rec_par,
                       const std::string& machine,
                       const std::string& flavor="VANILLA");

    //    const std::string* const getCalibTypeStr(eCalibType cType);
    //    const std::string* const getDataFmtStr(eDataFmt fmt);
    //    const std::string* const getInstrumentStr(eInstrument inst);

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

    // Might also want a "findAll" which would just return a list
    // of serial numbers, and a "getRecord" which would either
    // just return the full row as a string or parse it into 
    // its separate columns

    eRet getReadInfo(unsigned int serialNo, 
                     int *runFrm,
                     int *runTo,
                     std::string& dataFmt,
         //            std::string& fmtVersion,
                     std::string& dataIdent);

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

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

  eRet getReadDedxInfo(unsigned int serialNo, 
                     int *runFrm,
                     int *runTo,
                     std::string& calParVer,
                     DatabaseRecordVector& res,
                     int runNo,
                     std::string& sftver);
  
  eRet getReadMDCInfo(unsigned int serialNo, 
                     int *runFrm,
                     int *runTo,
                     std::string& calParVer,
                     DatabaseRecordVector& res,
                     int runNo,
                     std::string& sftver);
  
   eRet getReadMUCInfo(unsigned int serialNo,
                       int *runFrm,
                       int *runTo,
                       std::string& calParVer,
                       DatabaseRecordVector& res,
                       int runNo,
                       std::string& sftver);

   eRet getReadEsTimeInfo(unsigned int serialNo,   
                      int *runFrm,   
                      int *runTo,   
                      std::string& calParVer,   
                      DatabaseRecordVector& res,
                      int runNo,
                      std::string& sftver);   
  
   eRet getReadEstTofInfo(unsigned int serialNo,
                     int *runFrm,
                     int *runTo,
                     std::string& calParVer,
                     DatabaseRecordVector& res,
                     int runNo,
                     std::string& sftver);
   eRet getReadMdcAlignInfo(unsigned int serialNo,
         int *runFrm,
         int *runTo,
         std::string& calParVer,
         DatabaseRecordVector& res,
         int runNo,
         std::string& sftver);
   eRet getReadMdcDataConstInfo(unsigned int serialNo,
         int *runFrm,
         int *runTo,
         std::string& calParVer,
         DatabaseRecordVector& res,
         int runNo,
         std::string& sftver);
  eRet getReadTofQElecInfo(unsigned int serialNo,
         int *runFrm,
         int *runTo,
         std::string& calParVer,
         DatabaseRecordVector& res,
         int runNo,
         std::string& sftver);
  eRet getReadTofSimInfo(unsigned int serialNo,
         int *runFrm,
         int *runTo,
         std::string& calParVer,
         DatabaseRecordVector& res,
         int runNo,
         std::string& sftver);
   eRet getReadDedxSimInfo(unsigned int serialNo,
         int *runFrm,
         int *runTo,
         std::string& calParVer,
         DatabaseRecordVector& res,
         int runNo,
         std::string& sftver);



    // Insert a new record; return serial number if successful
    int registerCalib(const std::string& inst, 
                      const std::string& flavor,
                      const std::string& calib_type,
                      const std::string& data_ident,
                      const std::string& data_format,
                      unsigned int& runfrm,
                      unsigned int& runto,
                      const std::string& input_desc,
                      const std::string& notes,
                      const std::string& proc_level,
                      const std::string& locale,
                      const std::string& fmt_version = "",
                      const std::string& completion = "OK");
                    

    bool connectRead(eRet& err);


    bool checkValues(const rdbModel::StringVector& cols,
                     const rdbModel::StringVector& vals) const;

    bool checkNulls(const rdbModel::StringVector& cols) const;

    rdbModel::Connection* getReadConnection() {return m_readCxt;}
    
    // Should probably be const
    rdbModel::Rdb* getRdb() {return m_rdb;}
    const std::string& getTable() {return m_table;}

    // Might make these private
    void disconnectRead();
    void disconnectWrite();

  private:

    rdbModel::Connection* m_readCxt;
    rdbModel::Connection* m_writeCxt;

    // these could be static
    rdbModel::Assertion* m_findBest;
    rdbModel::Assertion* m_findSoonest;

    // For each pre-existing row satisfying certain conditions, 
    // set its vend = vstart of new row
    unsigned adjustVend(int newSer);
    

    /*
      Set val to string representation of "next" bit in levelMask
      (one of "PROD", "DEV", "TEST" or "SUPSED"),
      and mask off that bit in levelMask.  
    */
    bool fetchLevel(std::string& val, unsigned int *levelMask);

    //    void initConditions(std::vector<rdbModel::Operator *> conditions);

    //    bool addLevel(std::string& q, unsigned int *levelMask);

    /*  Use rdbModel::MysqlConnection::open( ..  )   to do most of the work */

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

    bool connectWrite(eRet& err);


    eRet compareSchema(rdbModel::Connection* conn,
                       const std::string& schema);
    // Find 'best' calibration, based on conditions and levelMask; store
    // serial number.
    //maqm fix 
     //eRet Metadata::doSelect(unsigned levelMask,
     eRet doSelect(std::vector<rdbModel::Assertion::Operator *>& 
                            conditions, 
                            rdbModel::StringVector& orderBy,
                            unsigned*& ser);
    
    eRet fetchUser(std::string& user);

    //    eRet compareSchema(const std::string& schema="");

    // Won't need followin enum or bit mask if we eliminate multi-step
    // insert procedure
    /*
    enum eRow {
      eOpened = 1,
      eValid = 2,
      eInputDesc = 4,
      eComment = 8,
      eFlavor  = 0x10,
      eLocale  = 0x20,
      eCreator = 0x40 };
    */
    //    static const unsigned int s_rowReady;

    //    std::string m_row;     // place to keep row as it's being built
    //    unsigned int m_rowStatus;
    std::string  m_host;
    std::string  m_table;
    std::string  m_dbName;
    rdbModel::Manager* m_man;
    rdbModel::Rdb* m_rdb;
    IDatabaseSvc* m_dbsvc;
    bool     m_match; // true if succeeded.  If not attempted, m_rdb is 0
  };
}

#endif

---