QDb.hh

Go to the documentation of this file.

 
#ifndef _QDB_HH_
#define _QDB_HH_
 
#include <string>
#include <vector>
#include <map>
 
// SDD FIXME -- 2018-01-05 -- replace with fwddecl (currently breaks cint)
#include "QVdt.hh"
#include "QError.hh"
 
#include "libpq-fe.h"
 
class QDbWatchdogThreadHandler;
class QWatchdogTimer;
 
namespace boost { class mutex; }
 
class QDb
{
public:
 
  virtual ~QDb();
 
  typedef std::vector<QVdt> column;
  typedef std::map<std::string, column> QDbTable;
 
  double DoQueryDouble(const std::string& query); 
  int DoQueryInt(const std::string& query); 
  bool DoQueryBool(const std::string& query);
  std::string DoQueryString(const std::string& query);
  std::vector<int> DoQueryVectorInt( const std::string& query);
  std::vector<double> DoQueryVectorDouble( const std::string& query);
  std::vector<std::string> DoQueryVectorString( const std::string& query);
 
   /*
    * This is (and must be) the only method that actually performs the
    * database queries (although it does so by exploiting other private
    * methods).
    * All other methods performing queries are wrappers around this method.
    * This is to ensure that all the connection mechanisms and error handling
    * is performed properly and always by the same code.
    */
   QError DoQuery(const std::string& query, QDbTable& table);
 
   /*
    * Simpler interface to DoQuery(), without error checking.
    * Throws a QError if something goes wrong.
    */
   QDbTable DoQuery(const std::string& query);
 
  QError DoSQLNoReturn(const std::string& query);
  int DoExec(const std::string& Query);
 
  int Insert(const std::string& tableName, const column& fields, const column & values);
 
   void SetConnectAttemptTimeoutSec(int timeout)
   { fConnectAttemptTimeoutSec = timeout; }
 
   /*
    * Set a range of values in seconds for extracting a random delay to
    * wait before opening a database connection.
    *
    * By default no delay is added when the connection is open.
    * The delay is only added if both minDelaySec and maxDelaySec have non
    * negative values and if maxDelaySec is larger than or equal to minDelaySec.
    * (if minDelaySec and maxDelaySec have the same value, the delay will be
    *  exactly minDelaySec).
    * The purpose of this delay is to avoid that a large number of analysis
    * jobs starting at the same time will also try to open the connection and
    * access the database at the same time, thus causing an overload of the
    * server.
    * Note that the random sleep is called once in Connect(), therefore it
    * would be repeated in case of multiple calls to Connect().
    */
   void SetConnectRandomDelaySec(double minDelaySec, double maxDelaySec)
   { fMinConnectDelaySec = minDelaySec; fMaxConnectDelaySec = maxDelaySec; }
 
   void SetDisconnectTimeoutSec(double timeout)
   { fDisconnectTimeoutSec = timeout; }
 
   /* Lock the mutex and call UnlockedDisconnect() */
   bool Disconnect();
   
protected:
 
   QDb(const std::string& dbHost,
       const std::string& dbPort,
       const std::string& dbUsr,
       const std::string& dbPwd,
       const std::string& dbName);
 
   bool IsConnected() const;
   inline const char* DataBase() const { return fDbName.c_str(); }
 
   // Friendship granted to allow the call to the protected method Disconnect()
   friend class QDbWatchdogThread;
   
private:
   
  PGconn *fConnection;
 
   const std::string fDbHost;
   const std::string fDbPort;
   const std::string fDbUser;
   const std::string fDbPwd;
   const std::string fDbName;
 
   // timeout for attempting db connection (defaults to 0)
   int fConnectAttemptTimeoutSec;
 
   /*
     These variables define the range for extracting a delay to wait
     before opening a database connection, set by SetConnectRandomDelaySec()
     and used by RandomWaitBeforeConnect();
   */
   double fMinConnectDelaySec;
   double fMaxConnectDelaySec;
 
   /* timeout for disconnecting after a certain period of inactivity */
   double fDisconnectTimeoutSec;
 
   QDbWatchdogThreadHandler* fThreadHandler;
   QWatchdogTimer* fWatchdogTimer;
   boost::mutex* fMutex;
 
   QError Connect();
   
   /*
    * Perform a disconnect without locking the mutex, used for the cases
    * when the mutex is already locked at a higher level (e.g. in Query()).
    */
   bool UnlockedDisconnect();
 
   QError Query(const std::string& query, PGresult** result);
   QError BasicQuery(const std::string& query, PGresult** result) const;
 
   QError CheckSingleResult(const QDbTable& table,
                            const std::string& query,
                            const std::string& funcName,
                            const std::string& file,
                            int line) const;
 
   QError ConnectBase();
 
   void RandomWaitBeforeConnect() const;
 
   QError InitWatchdogThread();
   QError UpdateWatchdogTimer();
};
#endif