JDB.hh

Go to the documentation of this file.

#ifndef __JDB_JDB__
#define __JDB_JDB__
 
#include <string>
#include <fstream>
#include <stdlib.h>
#include <vector>
 
#include <TDictionary.h>
#include <TClass.h>
#include <TDataMember.h>
#include <TIterator.h>
 
#include "JSystem/JStat.hh"
#include "JLang/JRedirectString.hh"
#include "JLang/JNullStream.hh"
#include "JLang/JException.hh"
#include "JROOT/JRootClass.hh"
#include "JROOT/JRootDictionary.hh"
#include "JROOT/JRootStreamer.hh"
#include "Jeep/JPrint.hh"
 
#include "dbclient/KM3NeTDBClient.h"
 
 
/**
 * \author mdejong
 */
namespace JDATABASE {}
namespace JPP { using namespace JDATABASE; }
 
namespace JDATABASE {
 
  using KM3NeT::DB::DBException;
  using KM3NeT::DB::Server;
  using KM3NeT::DB::Client;
  using KM3NeT::DB::ResultSet;
  using KM3NeT::DB::Selector;
  using JLANG::JDatabaseException;
 
  /**
   * Get private cookie.
   *
   * \return                  cookie
   */
  inline const char* getPrivateCookie()
  {
    const char* home = getenv("HOME");
 
    return MAKE_CSTRING((home != NULL ? home : ".") << "/" << ".km3netdb_cookie");
  }
 
 
  /**
   * Get public cookie.
   *
   * \return                  cookie
   */
  inline const char* getPublicCookie()
  {
    return getenv("DBCOOKIE");
  }
 
 
  /**
   * Cookie prefix.
   */
  static const char        PREFIX_COOKIE       =  '_';
 
 
  /**
   * Special characters.
   */
  static const std::string SPECIAL_CHARACTERS  =  "!@#$%^&*()-+=[]{};:'\"\\|,.<>/?";
 
 
  /**
   * This string is prepended to every parameter in the database output for the corresponding process.
   */
  static const std::string PREFIX_DATAFILTER   =  "DAQ_triggerParameters";
  static const std::string PREFIX_ADF          =  "DAQ_ADF";
 
 
  /**
   * Auxiliary class for connection to data base.
   */
  class JDB :
    public std::shared_ptr<Client>
  {
  public:
    /**
     * Get connection to database.
     *
     * \return               database connection
     */
    static JDB& get()
    {
      static JDB db;
 
      return db;
    }
 
 
    /**
     * Reset connection to database.
     */
    static void reset()
    {
      JDB& db = JDB::get();
 
      if (db.get() != NULL) {
        db->Close();
        static_cast<std::shared_ptr<Client>&>(db).reset();
      }
    }
 
 
    /**
     * Reset connection to database.
     *
     * \param  usr           user name
     * \param  pwd           pass word
     */
    static void reset(const std::string& usr,
                      const std::string& pwd)
    {
      static_cast<std::shared_ptr<Client>&>(JDB::get()) = Client::Create(Server::Default, usr.c_str(), pwd.c_str());
    }
 
    
    /**
     * Reset connection to database.
     *
     * \param  cookie        persistent cookie
     */
    static void reset(const std::string& cookie)
    {
      using namespace std;
      using namespace JPP;
 
      string buffer = cookie;
      
      if (getFileStatus(cookie.c_str())) {
 
        ifstream in(cookie.c_str());
 
        getline(in, buffer);
 
        in.close();
      }
 
      const string::size_type pos = buffer.find(PREFIX_COOKIE);
 
      if (pos != string::npos) {
        buffer.erase(0, pos);
      }
 
      static_cast<std::shared_ptr<Client>&>(JDB::get()) = Client::Create(Server::Default, buffer.c_str());
    }
 
 
    /**
     * Reset connection to database.
     *
     * An attempt to make a connection to the database is made in the following order,
     * using:
     *  -# user name and password, if neither empty;
     *  -# given   cookie, if not empty;
     *  -# private cookie file (created with JCookie.sh);
     *  -# public  cookie (defined by environment variable DBCOOKIE);
     *
     * \param  usr           user name
     * \param  pwd           password
     * \param  cookie        persistent cookie
     */
    static void reset(const std::string& usr,
                      const std::string& pwd,
                      const std::string& cookie)
    {
      using namespace std;
      using namespace JPP;
 
      if      (usr != "" && pwd != "")
        JDB::reset(usr, pwd);
      else if (cookie != "")
        JDB::reset(cookie);
      else if (getFileStatus(getPrivateCookie()))
        JDB::reset(getPrivateCookie());
      else if (getPublicCookie()  != NULL)
        JDB::reset(getPublicCookie());
      else
        THROW(JDatabaseException, "Missing user name / password or cookie file.");
    }
 
 
  private:
    /**
     * Default constructor.
     */
    JDB()
    {}
    
 
    JDB(const JDB&);
    JDB& operator=(const JDB&);
  };
 
 
  /**
   * Auxiliary class to read ROOT object from database.
   *
   * Note that the list of columns associated to the template parameter is considered to be permanent.\n
   * If not, the method JDBReader::reset should be called before the next operation.
   */
  template<class T>
  struct JDBReader {
    /**
     * Default constructor.
     */
    JDBReader() :
      object(),
      reader(JLANG::null, JLANG::JEquationParameters(), JROOT::JRootDictionary::getInstance())
    {}
 
 
    /**
     * Reset.
     */
    void reset()
    {
      buffer.clear();
    }
 
 
    /**
     * Read ROOT object from result set.
     *
     * \param  rs            result set
     * \return               object
     */
    const T& operator()(ResultSet& rs) 
    {
      using namespace std;
      using namespace JPP;
 
      object = T();
 
      if (buffer.empty()) {
 
        JRootReadableClass cls(object);
 
        for (size_t i = 0; i != rs.FieldCount(); ++i) {
 
          string parameter = rs.FieldName(i);
 
          for (string::const_iterator i = SPECIAL_CHARACTERS.begin(); i != SPECIAL_CHARACTERS.end(); ++i) {
            for (string::size_type pos; (pos = parameter.find(*i)) != string::npos; ) {
              parameter.erase(pos);
            }
          }
        
          buffer.push_back(cls.find(parameter.c_str()));
        }
      }
 
      for (unsigned int i = 0; i != rs.FieldCount(); ++i) {
 
        if (buffer[i].is_valid()) {     
 
          JRedirectString redirect(reader, rs.GetString(i));
      
          reader.getObject(buffer[i]);
        }
      }
 
      return object;
    }
 
  private:
    T                  object;
    JROOT::JRootReader reader;
 
    std::vector<JROOT::JRootReadableClass> buffer;  // field count -> data member
  };
 
 
  /**
   * Read ROOT object from result set.
   *
   * \param  rs            result set
   * \param  object        object
   * \return               true if read; else false
   */
  template<class T>
  inline bool operator>>(ResultSet& rs, T& object)
  {
    static JDBReader<T> reader;
 
    if (rs.Next()) {
 
      object = reader(rs);
 
      return true;
    }
 
    return false;
  }
 
 
  /**
   * Read vector of ROOT objects from result set.
   *
   * \param  rs            result set
   * \param  buffer
   * \return               true if read; else false
   */
  template<class JElement_t, class JAllocator_t>
  inline bool operator>>(ResultSet& rs, std::vector<JElement_t, JAllocator_t>& buffer)
  {
    for (JElement_t object; rs >> object; ) {
      buffer.push_back(object);
    }
 
    return true;
  }
 
 
  /**
   * Get table name.
   *
   * \return               table name
   */
  template<class JTable_t>
  inline const char* getTable()
  {
    return JTable_t::getName();
  }
 
 
  /**
   * Get column name.
   *
   * \param  data_member   data member
   * \return               column name
   */
  template<class JTable_t, class JType_t>
  inline const char* getColumn(JType_t JTable_t::*data_member)
  {
    JTable_t* pc = NULL;
    TClass*   rc = dynamic_cast<TClass*>(TDictionary::GetDictionary(typeid(JTable_t)));
 
    if (rc != NULL) {
 
      TIterator* i = rc->GetListOfDataMembers()->MakeIterator();
 
      for (const TDataMember* p; (p = (const TDataMember*) i->Next()) != NULL; ) {
 
        if (p->GetOffset() == (char*) &(pc->*data_member) - (char*) pc) {
          return p->GetName();
        }
      }
    }
 
    return NULL;
  }
 
 
  /**
   * Get column names.
   *
   * \return               column names
   */
  template<class JTable_t>
  inline std::vector<std::string> getColumns()
  {
    using namespace JPP;
 
    std::vector<std::string> buffer;
 
    TClass*   rc = dynamic_cast<TClass*>(TDictionary::GetDictionary(typeid(JTable_t)));
 
    if (rc != NULL) {
 
      TIterator* i = rc->GetListOfDataMembers()->MakeIterator();
 
      for (const TDataMember* p; (p = (const TDataMember*) i->Next()) != NULL; ) {
        if (JRootClass::is_class(*p)) {
          buffer.push_back(p->GetName());
        }
      }
    }
 
    return buffer;
  }
 
 
  /**
   * Get result set.
   *
   * \param  query         query / table name
   * \return               result set
   */
  inline ResultSet& getResultSet(const std::string& query)
  {
    return JDB::get()->StreamDS(query.c_str(), std::vector<Selector>());
  }
 
 
  /**
   * Get result set.
   *
   * \param  query         query / table name
   * \param  selection     selection
   * \return               result set
   */
  inline ResultSet& getResultSet(const std::string& query, const std::vector<Selector>& selection)
  {
    return JDB::get()->StreamDS(query.c_str(), selection);
  }
}
 
#endif