DBInterface.h

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: DBInterface.h,v 1.7.10.2 2007/08/07 12:31:11 oliver Exp $
//
// Author:
//   Oliver Kohlbacher
//

#ifndef BALL_FORMAT_DBINTERFACE_H
#define BALL_FORMAT_DBINTERFACE_H

#include <BALL/KERNEL/system.h>
#include <BALL/KERNEL/molecule.h>
#include <BALL/FORMAT/MOLFile.h>
#include <BALL/COMMON/exception.h>

#include <QtSql/qsqlrecord.h>
#include <QtSql/qsqldatabase.h>
#include <QtSql/qsqlquery.h>
#include <QtCore/qvariant.h>

namespace BALL
{

  class BALL_EXPORT DBInterface
  {
    public:
    
    class InvalidQuery
      : public Exception::GeneralException
    {
      public:
      InvalidQuery(const char* file, int line, const String& s = "<unknown query>") ;
      virtual ~InvalidQuery() throw() {}

      protected:
      std::string query_;
    };

    class NotConnected
      : public Exception::GeneralException
    {
      public:
      NotConnected(const char* file, int line, const String& s = "<not connected>") ;
      virtual ~NotConnected() throw() {}

      protected:
      std::string query_;
    };

    class InconsistentTopology
      : public Exception::GeneralException
    {
      public:
      InconsistentTopology(const char* file, int line, const String& s = "<inconsistent topology>") ;
      virtual ~InconsistentTopology() throw() {}

      protected:
      std::string query_;
    };

      
    typedef qlonglong ID;

    typedef std::vector<ID> IDVector;

    typedef std::pair<String, String> ConformationMethod;

    typedef std::pair<String, String> ChargeMethod;


    enum ErrorCodes
    {
      NO_ERROR,
      NO_CONNECTION // the database was not connected/initialized (good() = false)
    };

    static const String BALL_DEFAULT_DBRCFILE;
    static const String BALL_DEFAULT_DATABASE_HOST;
    static const Size   BALL_DEFAULT_DATABASE_PORT;
    static const String BALL_DEFAULT_DATABASE_DRIVER;
    static const String BALL_DEFAULT_DATABASE_NAME;
    static const String BALL_DEFAULT_DATABASE_SECTIONNAME;
    


    DBInterface();
    virtual ~DBInterface() {}


    void getTopology(ID topology, System& system);
    ID newTopology(const System& system, const String& name, const String& source_id, ID id = 0);
    void setTopology(ID topology, const System& system);

    IDVector getConformationList(ID topology_od);
    IDVector getConformationList(ID topology_id, ID method_id);
    void loadConformation(const ID conformation, System& system);

    ID storeConformation(ID topology_id, ID method_id, const System& system,double energy);
    ID storeConformation(ID topology, ID method_ID, const System& system);

    IDVector getConformationMethods();
    ConformationMethod getConformationMethod(ID method_id);
    ID getConformationMethod(const String& method, const String& parameters);
    ID newConformationMethod(const String& method, const String& parameters);
        
    ID storeCharges(ID topology_id, ID method_id, const System& system);
    void loadCharges(const ID charge_id, System& system);
    IDVector getChargeMethods();
    ChargeMethod getChargeMethod(DBInterface::ID method_id);
    ID getChargeMethod(const String& method, const String& parameters);
    ID newChargeMethod(const String& method, const String& parameters);

    ErrorCode getError() const { return error_; }
    void setError(ErrorCode error) { error_ = error; }
    bool good() const { return error_ == 0; }

    bool connect
      (const String& user, const String& password, 
       const String& database_name = "structures", const String& host = "diclofenac.informatik.uni-tuebingen.de",
       Size port = 3306, const String& driver = "QMYSQL3");

    bool connect();
    
    QSqlQuery& executeQuery(const String& query_string) 
      throw(InvalidQuery, NotConnected);
    
    QSqlQuery& executeQuery() 
      throw(InvalidQuery, NotConnected);

    QSqlQuery& query() { return *query_; }

    String executedQuery() { return query_->executedQuery().toStdString();}

    bool first() { return query_->first(); }

    bool last() { return query_->last(); }

    bool next() { return query_->next(); }

    IDVector extractIDs();

    bool prev() { return query_->previous(); }

    ID lastInsertedID();
    
    Size size() { return (Size)query_->size(); }

    QVariant value(Position k) { return query_->value(k); }

    void prepare(const String& s) { query_->prepare(s.c_str()); }

    void addBindValue(const QVariant& v) { query_->addBindValue(v); }
    void addBindValue(const QVariant& v1, const QVariant& v2) { addBindValue(v1); addBindValue(v2);}
    void addBindValue(const QVariant& v1, const QVariant& v2, const QVariant& v3) { addBindValue(v1); addBindValue(v2); addBindValue(v3);}
    void addBindValue(const QVariant& v1, const QVariant& v2, const QVariant& v3, const QVariant& v4) { addBindValue(v1); addBindValue(v2); addBindValue(v3); addBindValue(v4);}


    bool getMOLFile(ID id, String& file_text, String& name, String& source_id);
    void addMOLFileToSystem(const String& molfile, System& system);

    protected:  

    static void assignCoordinates_(System& system, const QByteArray& data);
    static void extractCoordinates_(const System& system, QByteArray& data);
    static void assignCharges_(System& system, const QByteArray& data);
    static void extractCharges_(const System& system, QByteArray& data);
    static void encodeArray_(const std::vector<float>& v, QByteArray& a);
    static void decodeArray_(const QByteArray& a, std::vector<float>& v);

    // Database conection
    ErrorCode       error_;
    QSqlDatabase    db_;
    QSqlQuery*      query_;
    
    // Connection details
    String          database_name_;
    Size            port_;
    String          host_;
    String          username_;
    String          password_;

    private:
    // No copy construction allowed. Don't know what QSqlDatabase would
    // do in that case. It can't be copied anyhow...
    DBInterface(const DBInterface& /* interface */) {}
  };

} // namespace BALL
#endif // BALL_FORMAT_DBINTERFACE_H

---