query/backends/sqlite/src/sqlite_query_result.cpp

#include "sqlite_query_result.hpp"

#include <cstring>
#include <stdexcept>

namespace matador::backends::sqlite {

template < class Type >
void read(Type &x, const char *val, typename std::enable_if<std::is_integral<Type>::value && std::is_signed<Type>::value>::type* = nullptr)
{
  if (strlen(val) == 0) {
    return;
  }
  char *end;
  x = static_cast<Type>(strtoll(val, &end, 10));
  if (end != nullptr) {
    // Todo: check error
    throw std::logic_error("couldn't convert value to number");
  }
}

template < class Type >
void read(Type &x, const char *val, typename std::enable_if<std::is_integral<Type>::value && std::is_unsigned<Type>::value>::type* = nullptr)
{
  if (strlen(val) == 0) {
    return;
  }
  char *end;
  x = static_cast<Type>(strtoull(val, &end, 10));
  if (end != nullptr) {
    // Todo: check error
    throw std::logic_error("couldn't convert value to number");
  }
}

template < class Type >
void read(Type &x, const char *val, typename std::enable_if<std::is_floating_point<Type>::value>::type* = nullptr)
{
  if (strlen(val) == 0) {
    return;
  }
  char *end;
  x = static_cast<Type>(strtold(val, &end));
  if (end != nullptr) {
    // Todo: check error
    throw std::logic_error("couldn't convert value to number");
  }
}

void sqlite_query_result::read_value(const char *id, size_t index, char &value)
{
  read(value, result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, short &value)
{
  read(value, result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, int &value)
{
  read(value, result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, long &value)
{
  read(value, result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, long long int &value)
{
  read(value, result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, unsigned char &value)
{
  read(value, result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, unsigned short &value)
{
  read(value, result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, unsigned int &value)
{
  read(value, result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, unsigned long &value)
{
  read(value, result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, unsigned long long int &value)
{
  read(value, result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, bool &value)
{
  read(value, result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, float &value)
{
  read(value, result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, double &value)
{
  read(value, result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, char *value, size_t size)
{
  auto val = result_[row_index_][index];
  size_t len = strlen(val);
  if (len > size) {
#ifdef _MSC_VER
    strncpy_s(value, size, val, len);
#else
    strncpy(value, val, size);
#endif
    value[size-1] = '\n';
  } else {
#ifdef _MSC_VER
    strcpy_s(value, size, val);
#else
    strcpy(value, val);
#endif
  }
}

void sqlite_query_result::read_value(const char *id, size_t index, std::string &value)
{
  value.assign(result_[row_index_][index]);
}

void sqlite_query_result::read_value(const char *id, size_t index, std::string &value, size_t s)
{
  value.assign(result_[row_index_][index]);
}

void sqlite_query_result::push_back(char **row_values, int column_count)
{
  columns data;
  for(int i = 0; i < column_count; ++i) {
    // copy and store column data;
    if (row_values[i] == nullptr) {
      auto val = new char[1];
      val[0] = '\0';
      data.push_back(val);
    } else {
      size_t size = strlen(row_values[i]);
      auto val = new char[size + 1];
      std::memcpy(val, row_values[i], size);
      val[size] = '\0';
      data.push_back(val);
    }
  }
  result_.emplace_back(data);
}

bool sqlite_query_result::next_row()
{
  column_index_ = 0;
  return row_index_++ < result_.size();
}

}