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 "dbclient/KM3NeTDBClient.h"

#include "JSystem/JStat.hh"
#include "JLang/JManip.hh"

#include "JDB/JDBReader.hh"


/**
 * \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       =  '_';


  /**
   * 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&);
  };


  /**
   * 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