VSQLManager_impl_SQLite.h

Go to the documentation of this file.

#ifndef _det_VSQLManager_impl_h_
#define _det_VSQLManager_impl_h_

#include <iostream>

using namespace std;

template<typename T>
VSQLManager::Status
VSQLManager::FetchRow(T& data, const bool freeResult)
  const
{
  if (fResult && (FetchRow() == SQLITE_ROW)) {
    if (sqlite3_column_count(fResult) >= 1) {
      
      // NULL entry should be interpreted as result not found
      if (sqlite3_column_type(fResult, 0) == SQLITE_NULL) {
        if (freeResult)
          FreeResult();
        return eNotFound;
      }
      try {
        data = boost::lexical_cast<T>(sqlite3_column_text(fResult, 0));
      }
      catch (const boost::bad_lexical_cast& e) {
        ERROR(e.what());
      }
    }
    if (freeResult)
      FreeResult();

    return eFound;
  }
  FreeResult();
  return eNotFound;
}

template<typename T>
VSQLManager::Status
VSQLManager::FetchRow(std::vector<T>& data, const bool freeResult)
  const
{
  // FetchRow returns SQLITE_DONE when no more result
  if ( fResult && (FetchRow() == SQLITE_ROW) ) {
    data.clear();
    for (int i = 0; i < sqlite3_column_count(fResult); ++i) {
      //in case of NULL column-count will be 1 but column_text returns null-pointer, which causes seg-fault in cast below
      if ( sqlite3_column_bytes(fResult, i) ) {
        try {
          data.push_back(
            boost::lexical_cast<T>(sqlite3_column_text(fResult, i)));
        }
        catch (const boost::bad_lexical_cast& e) {
          ERROR(e.what());
        }
      }
    }
    if (freeResult)
      FreeResult();

    if (data.size()) {
      return eFound;
    } else {
      return eNotFound;
    }
  }

  FreeResult();
  return eNotFound;
}

template<typename TH, typename TT>
VSQLManager::Status
VSQLManager::FetchRowTuple(boost::tuples::cons<TH, TT>& tuple, const int idx)
  const
{
  if (idx < sqlite3_column_count(fResult)) {
    try {
      tuple.get_head() = boost::lexical_cast<TH>(
                           sqlite3_column_text(fResult, idx));
    }
    catch (const boost::bad_lexical_cast& e) {
      ERROR(e.what());
    }
    return FetchRowTuple(tuple.get_tail(), idx + 1);
  }
  else {
    return eNotFound;
  }
}

template<typename TH, typename TT>
VSQLManager::Status
VSQLManager::FetchRowMany(boost::tuples::cons<TH, TT>& tuple, const bool freeResult)
  const
{
  if (fResult && (FetchRow() == SQLITE_ROW)) {
    const Status status = FetchRowTuple(tuple);
    if (status == eNotFound || freeResult)
      FreeResult();

    return status;
  }
  FreeResult();
  return eNotFound;
}

template<typename T>
VSQLManager::Status
VSQLManager::FetchColumn(std::vector<T>& data)
  const
{
  if (fResult) {
    data.clear();
    while (FetchRow() == SQLITE_ROW) {
      if (sqlite3_column_count(fResult) >= 1) {
        try {
          data.push_back(
            boost::lexical_cast<T>(sqlite3_column_text(fResult, 0)));
        }
        catch (const boost::bad_lexical_cast& e) {
          ERROR(e.what());
        }
      }
    }
    FreeResult();
    return eFound;
  }
  FreeResult();
  return eNotFound;
}

#endif // _det_VSQLManager_impl_h_