query/src/sql/query_result_reader.cpp

#include "matador/sql/query_result_reader.hpp"
#include "matador/sql/to_value.hpp"

namespace matador::sql {

void query_result_reader::read_value(const char *id, size_t index, char &value)
{
  sql::to_value(value, column(index));
}

void query_result_reader::read_value(const char *id, size_t index, short &value)
{
  sql::to_value(value, column(index));
}

void query_result_reader::read_value(const char *id, size_t index, int &value)
{
  sql::to_value(value, column(index));
}

void query_result_reader::read_value(const char *id, size_t index, long &value)
{
  sql::to_value(value, column(index));
}

void query_result_reader::read_value(const char *id, size_t index, long long int &value)
{
  sql::to_value(value, column(index));
}

void query_result_reader::read_value(const char *id, size_t index, unsigned char &value)
{
  sql::to_value(value, column(index));
}

void query_result_reader::read_value(const char *id, size_t index, unsigned short &value)
{
  sql::to_value(value, column(index));
}

void query_result_reader::read_value(const char *id, size_t index, unsigned int &value)
{
  sql::to_value(value, column(index));
}

void query_result_reader::read_value(const char *id, size_t index, unsigned long &value)
{
  sql::to_value(value, column(index));
}

void query_result_reader::read_value(const char *id, size_t index, unsigned long long int &value)
{
  sql::to_value(value, column(index));
}

void query_result_reader::read_value(const char *id, size_t index, bool &value)
{
  sql::to_value(value, column(index));
}

void query_result_reader::read_value(const char *id, size_t index, float &value)
{
  sql::to_value(value, column(index));
}

void query_result_reader::read_value(const char *id, size_t index, double &value)
{
  sql::to_value(value, column(index));
}

void query_result_reader::read_value(const char *id, size_t index, char *value, size_t size)
{
  auto val = column(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 query_result_reader::read_value(const char *id, size_t index, std::string &value)
{
  value.assign(column(index));
}

void query_result_reader::read_value(const char *id, size_t index, std::string &value, size_t s)
{
  value.assign(column(index));
}

template < typename Type >
void convert(const char *valstr, sql::any_type &value)
{
  Type val{};
  sql::to_value(val, valstr);
  value = val;
}

void query_result_reader::read_value(const char *id, size_t index, any_type &value, data_type_t type, size_t size)
{
  switch (type) {
    case sql::data_type_t::type_char:
      convert<char>(column(index), value);
      break;
    case sql::data_type_t::type_short:
      convert<short>(column(index), value);
      break;
    case sql::data_type_t::type_int:
      convert<int>(column(index), value);
      break;
    case sql::data_type_t::type_long:
      convert<long>(column(index), value);
      break;
    case sql::data_type_t::type_long_long:
      convert<long long>(column(index), value);
      break;
    case sql::data_type_t::type_unsigned_char:
      convert<unsigned char>(column(index), value);
      break;
    case sql::data_type_t::type_unsigned_short:
      convert<unsigned short>(column(index), value);
      break;
    case sql::data_type_t::type_unsigned_int:
      convert<unsigned int>(column(index), value);
      break;
    case sql::data_type_t::type_unsigned_long:
      convert<unsigned long>(column(index), value);
      break;
    case sql::data_type_t::type_unsigned_long_long:
      convert<unsigned long long>(column(index), value);
      break;
    case sql::data_type_t::type_float:
      convert<float>(column(index), value);
      break;
    case sql::data_type_t::type_double:
      convert<double>(column(index), value);
      break;
    case sql::data_type_t::type_bool: {
      int val{};
      sql::to_value(val, column(index));
      value = val > 0;
      break;
    }
    case sql::data_type_t::type_text:
    case sql::data_type_t::type_varchar: {
      value = std::string{column(index)};
      break;
    }
    case sql::data_type_t::type_char_pointer: {
      value = column(index);
      break;
    }
    case sql::data_type_t::type_time:
    case sql::data_type_t::type_date: {
      value = std::string{column(index)};
      break;
    }
    case sql::data_type_t::type_null: {
      value = nullptr_t{};
      break;
    }
    case sql::data_type_t::type_blob: {
      throw std::logic_error("data type blob not supported");
    }
    case sql::data_type_t::type_unknown: {
      value = std::string(column(index));
      break;
    }
  }
}

}