VSQLManager_MySQL.h

Go to the documentation of this file.

#ifndef _det_VSQLManager_MySQL_h_
#define _det_VSQLManager_MySQL_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 <mysql/mysql.h>

#include <det/VManager.h>
#include <utl/RealTimeStopwatch.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(); }

    static void SetGlobalLogQueries(const int q) { fgGlobalLogQueries = q; }

  protected:
    void Close();

    virtual void Init(const std::string& configLink);

    void Connect() const;

    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& result, const bool free = true)
      const
    {
      const MYSQL_ROW row = FetchRow();
      if (row && row[0]) {
        try {
          result = boost::lexical_cast<T>(row[0]);
        } catch (boost::bad_lexical_cast&) {
          BadLexicalCast<T>(row[0], "preserving original value");
        }
        if (free)
          FreeResult();
        return eFound;
      }
      FreeResult();
      return eNotFound;
    }

    template<typename T>
    Status
    FetchRow(std::vector<T>& result, const bool free = true)
      const
    {
      const MYSQL_ROW row = FetchRow();
      if (row) {
        const int n = NumFields();
        result.resize(n);
        for (int i = 0; i < n; ++i) {
          try {
            if (!row[i]) {
              result[i] = boost::lexical_cast<T>("");
              ERROR("Empty field returned from sql-query!");
            } else {
              result[i] = boost::lexical_cast<T>(row[i]);
            }
          } catch (boost::bad_lexical_cast&) {
            BadLexicalCast<T>(row[i], "preserving original value");
          }
        }
        if (free)
          FreeResult();
        return eFound;
      }
      FreeResult();
      return eNotFound;
    }

    template<typename TH, typename TT>
    Status
    FetchRowMany(boost::tuples::cons<TH, TT>& tuple, const bool free = true)
      const
    {
      const MYSQL_ROW row = FetchRow();
      if (row) {
        const Status status = FetchRowTuple(row, tuple);
        if (status == eNotFound || free)
          FreeResult();
        return status;
      }
      FreeResult();
      return eNotFound;
    }

    template<typename T>
    Status
    FetchColumn(std::vector<T>& result)
      const
    {
      MYSQL_ROW row;
      while ((row = FetchRow()))
        if (row[0]) {
          try {
            result.push_back(boost::lexical_cast<T>(row[0]));
          } catch (boost::bad_lexical_cast&) {
            BadLexicalCast<T>(row[0], "some rows will be missing");
          }
        } else {
          FreeResult();
          return eNotFound;
        }
      FreeResult();
      return eFound;
    }

    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 mysql_num_fields(NeedsResult()); }

    size_t NumRows() const
    { return mysql_num_rows(NeedsResult()); }

    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);
    }

    mutable std::string fDatabaseSoftwareVersion;

    void
    FreeResult()
      const
    {
      if (fMySQLResult) {
        mysql_free_result(fMySQLResult);
        fMySQLResult = nullptr;
      }
    }

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

  private:
    MYSQL_RES*
    NeedsResult()
      const
    {
      if (fMySQLResult)
        return fMySQLResult;
      const std::string err = "Empty MySQL result queue.";
      ERROR(err);
      throw utl::IOFailureException(err);
    }

  protected:
    MYSQL_ROW FetchRow() const { return mysql_fetch_row(NeedsResult()); }

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

    template<typename TH, typename TT>
    Status
    FetchRowTuple(const MYSQL_ROW row, boost::tuples::cons<TH, TT>& tuple,
                  const int index = 0)
      const
    {
      if (row[index]) {
        try {
          tuple.get_head() = boost::lexical_cast<TH>(row[index]);
        } catch (boost::bad_lexical_cast&) {
          BadLexicalCast<TH>(row[index], "some columns will be missing");
        }
        return FetchRowTuple(row, tuple.get_tail(), index+1);
      } else
        return eNotFound;
    }

    template<typename T>
    static
    void
    BadLexicalCast(const char* const row, const std::string& action)
    {
      std::ostringstream err;
      err << "Bad lexical cast from '";
      int i = 30;
      for (int j = 0; i > 0 && row[j]; ++j) {
        err << (isprint(row[j]) ? row[j] : '.');
        --i;
      }
      if (i)
        err << "[truncated]";
      err << "' to ";
#ifdef __GNUC__
      int status;
      err << abi::__cxa_demangle(typeid(T).name(), 0, 0, &status);
#else
      err << typeid(T).name();
#endif
      err << "; " << action << '.';
      ERROR(err);
    }

    // database info
    mutable std::string fDatabaseServer;
    mutable std::string fDatabaseUserName;
    mutable std::string fDatabasePassword;
    mutable std::string fDatabaseName;

    mutable int fPort = -1;

    mutable MYSQL* fMySQL = nullptr;
    mutable MYSQL_RES* fMySQLResult = nullptr;

    mutable utl::RealTimeStopwatch fTime{false};
    mutable int fLogQueries = 0;
    mutable std::ofstream* fLogQueryStream = nullptr;
    static int fgGlobalLogQueries;

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

  };

}


#endif