/home/tobi/workspace/solarpowerlog/src/interfaces/PersistanceStorage/QueryHelper.cpp

Go to the documentation of this file.

/*
 * _QueryHelper.cpp
 *
 *  Created on: Feb 7, 2010
 *      Author: tobi
 */

#include "QueryHelper.h"

#include <assert.h>

QueryHelper::QueryHelper(dbixx::session *session,
          std::map<std::string, dbtypes> *table_spec)
{
     this->table_spec = table_spec;
     this->session = session;
     this->r = NULL;
}

QueryHelper::~QueryHelper()
{
     if (r)
          delete r;
}

int QueryHelper::DoQuery(std::vector<std::string> &what, std::string &where)
{
     assert(session);
     if (!r) {
          r = new dbixx::result;
     }

     try {
          // store infos for later retrival
          this->what = what;

          // build query
          *session << "SELECT ";

          if (what.size() == 1) {
               *session << what[0];
          } else {
               bool first = true;
               std::vector<std::string>::iterator it;
               while (it != what.end()) {
                    if (first) {
                         *session << (*it);
                         first = false;
                    } else {
                         *session << "," << (*it);
                    }
               }
          }

          *session << " " << where;

          // now run query, assign result and return the number of rows.
          session->fetch(*r);
          return r->rows();
     } catch (dbixx::dbixx_error const &e) {
          // fixme: we need to have access of the logger here....
          this->what.clear();
          std::runtime_error ex(std::string("query ") + e.query()
                    + " failed with " + e.what());
          delete r;
          r = 0;
          throw ex;
     }
}

std::map<std::string, boost::any> QueryHelper::GetNextResult(void)
{
     // no results without searches.
     assert(r);

     dbixx::row row;
     if (!r->next(row)) {
          std::runtime_error ex(std::string("unexpected getnextresult"));
          throw ex;
     }

     std::vector<std::string>::iterator columns_it;
     std::map<std::string, boost::any> result_map;
     std::pair<std::string, boost::any> p;
     int i = 0;

     dbtypes type_wanted;
     for (i = 0, columns_it = what.begin(); columns_it != what.end(); i++, columns_it++) {
          p.first = *columns_it;

          std::map<std::string, dbtypes>::iterator ts_it = table_spec->find(
                    *columns_it);
          if (ts_it == table_spec->end() || ts_it->second == db_string) {
               type_wanted = db_string;
          } else {
               type_wanted = ts_it->second;
          }

          switch (type_wanted)
          {

          case db_string:
          {
               std::string t;
               if (!row.fetch(i, t))
                    break;
               p.second = boost::any(t);
               result_map.insert(p);
               break;
          }

          case db_integer:
          case db_unsignedinteger:
          {
               long long intermediate;
               long t;
               if (!row.fetch(i, intermediate))
                    break;
               t = intermediate;
               p.second = boost::any(t);
               result_map.insert(p);
               break;
          }

          case db_longlong:
          {
               long long t;
               if (!row.fetch(i, t))
                    break;
               p.second = boost::any(t);
               result_map.insert(p);
               break;
          }

          case db_unsignedlonglong:
          {
               unsigned long long t;
               if (!row.fetch(i, t))
                    break;
               p.second = boost::any(t);
               result_map.insert(p);
               break;
          }

          case db_decimal:
          {
               double t;
               if (!row.fetch(i, t))
                    break;
               p.second = boost::any(t);
               result_map.insert(p);
               break;
          }

          case db_tm:
          {
               std::tm tm;
               if (!row.fetch(i, tm))
                    break;
               p.second = boost::any(tm);
               result_map.insert(p);
               break;
          }

          }
     }

     return result_map;

}