VSQLManager_SQLite.h

Go to the documentation of this file.

#ifndef _det_VSQLManager_h_
#define _det_VSQLManager_h_

#include <stddef.h>
#include <ctype.h>
#ifdef __GNUC__
#  include <cxxabi.h>
#endif
#include <sstream>
#include <fstream>

#include <boost/tuple/tuple.hpp>
#include <boost/lexical_cast.hpp>

#include <det/VManager.h>
#include <utl/RealTimeStopwatch.h>

#include <sqlite3.h>


/* Use this macro to call the generic GetDBData() method of the VSQLManager */
#define VSQLMANAGER_GETDATA_GETDBDATA(_T_...) \
          VMANAGER_GETDATA_CALL(GetDBData, _T_)


namespace det {

  class VSQLManager : public det::VManager {

  public:
    VSQLManager() { }
    virtual ~VSQLManager() { Close(); }

  protected:
    void Close();

    // to be modified to get file name
    virtual void Init(const std::string& configLink);

    Status Query(const std::ostringstream& os, const std::string& what = "") const
    { return Query(os.str(), what); }

    Status Query(const std::string& query, const std::string& what = "") const;

    Status Query(const std::ostringstream& os, const std::ostringstream& what) const
    { return Query(os.str(), what.str()); }

    template<typename T>
    Status FetchRow(T& data, const bool freeResult = true) const;

    template<typename T>
    Status FetchRow(std::vector<T>& data, const bool freeResult = true) const;

    template<typename TH, typename TT>
    Status FetchRowMany(boost::tuples::cons<TH, TT>& tuple,
                        const bool freeResult = true) const;

    template<typename T>
    Status FetchColumn(std::vector<T>& data) const;

    template<typename T> Status FetchNextRow(T& result) const
    { return FetchRow(result, false); }

    template<typename TH, typename TT>
    Status FetchNextRowMany(boost::tuples::cons<TH, TT>& result) const
    { return FetchRowMany(result, false); }

    unsigned int NumFields() const
    { return sqlite3_column_count(fResult); }

    virtual Status GetDBResFundamental(const std::string&,
                                       const std::string&,
                                       const IndexMap&) const
    { ERROR("Should not be used!"); return eNotFound; }

    template<typename T>
    Status
    GetDBData(T& returnData,
              const std::string& tableName,
              const std::string& columnName,
              const IndexMap& componentIndex)
      const
    {
      if (GetDBResFundamental(tableName, columnName, componentIndex) == eNotFound)
        return eNotFound;
      return FetchRow(returnData);
    }

    virtual Status GetDBResVector(const std::string&,
                                  const std::string&,
                                  const IndexMap&) const
    { ERROR("Should not be used!"); return eNotFound; }

    template<typename T>
    Status
    GetDBData(std::vector<T>& returnData,
              const std::string& tableName,
              const std::string& columnName,
              const IndexMap& componentIndex)
      const
    {
      if (GetDBResVector(tableName, columnName, componentIndex) == eNotFound)
        return eNotFound;
      return FetchColumn(returnData);
    }

    int FreeResult() const;

    std::string fDatabaseSoftwareVersion;

    static std::string MergeIndexMap(const IndexMap& componentIndex);

  private:
    Status FetchRowTuple(const boost::tuples::null_type&, const int) const
    { return eFound; }

    template<typename TH, typename TT>
    Status FetchRowTuple(boost::tuples::cons<TH, TT>& tuple, const int idx = 0) const;

    std::string fDatabaseName; 
    sqlite3* fDb = nullptr; 
    mutable sqlite3_stmt* fResult = nullptr; 

    int FetchRow() const;

    mutable utl::RealTimeStopwatch fTime{false};
    /* int fLogQueries; */
    /* std::ofstream* fLogQueryStream; */

    // disable copying
    VSQLManager(const VSQLManager&);
    VSQLManager& operator=(const VSQLManager&);

  };

#include <det/VSQLManager_impl_SQLite.h>

}


#endif