result.hpp

Go to the documentation of this file.

#pragma once
 
#include "../query/core.hpp"
#include "../query/meta.hpp"
#include "../schema/core.hpp"
#include "../schema/table.hpp"
 
#include <array>
#include <concepts>
#include <expected>
#include <functional>
#include <iostream>
#include <optional>
#include <ranges>
#include <sstream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace relx::result {
 
struct ResultError {
  std::string message;
};
 
template <typename T>
using ResultProcessingResult = std::expected<T, ResultError>;
 
template <typename T, typename C>
static constexpr auto class_of(T C::*) {
  return (C*)nullptr;
}
 
template <auto MemberPtr>
constexpr std::string_view get_column_name() {
  using Class = query::class_of_t_t<decltype(MemberPtr)>;
  using ColumnType = std::remove_reference_t<decltype(std::declval<Class>().*MemberPtr)>;
  return ColumnType::column_name;
}
 
template <typename Table, typename ColumnMemberPtr>
struct column_member_value {
  using column_type =
      std::remove_reference_t<decltype(std::declval<Table>().*std::declval<ColumnMemberPtr>())>;
  using type = typename column_type::value_type;
};
 
template <typename Table, typename ColumnMemberPtr>
using column_member_value_t = typename column_member_value<Table, ColumnMemberPtr>::type;
 
template <typename Table, typename ColumnMemberPtr>
std::string get_column_name_from_ptr(ColumnMemberPtr ptr) {
  using ColumnType = std::remove_reference_t<decltype(std::declval<Table>().*ptr)>;
  return std::string(ColumnType::name);
}
 
class Cell {
public:
  explicit Cell(std::string value) : value_(std::move(value)) {}
 
  bool is_null() const { return value_ == "NULL"; }
 
  const std::string& raw_value() const { return value_; }
 
  template <typename T>
  ResultProcessingResult<T> as() const {
    return as<T>(false);
  }
 
  template <typename T>
  ResultProcessingResult<T> as(bool allow_numeric_bools) const {
    if (is_null()) {
      if constexpr (is_optional_v<T>) {
        return T{std::nullopt};
      }
      return std::unexpected(ResultError{"Cannot convert NULL to non-optional type"});
    }
 
    // More strict type checking
    if constexpr (std::is_same_v<T, bool>) {
      const auto lower = to_lower(value_);
 
      // Always accept explicit boolean strings
      if (lower == "true") {
        return true;
      }
      if (lower == "false") {
        return false;
      }
      if (lower == "t") {  // PostgreSQL format
        return true;
      }
      if (lower == "f") {  // PostgreSQL format
        return false;
      }
      if (allow_numeric_bools) {
        // Only allow numeric conversion if explicitly allowed
        if (lower == "1") {
          return true;
        }
        if (lower == "0") {
          return false;
        }
      }
 
      return std::unexpected(ResultError{std::string("Cannot convert '") + value_ +
                                         "' to boolean: not a boolean value"});
    } else if constexpr (std::is_same_v<T, int> || std::is_same_v<T, long> ||
                         std::is_same_v<T, long long>) {
      // For integer types, reject any attempt to convert from boolean strings
      const auto lower = to_lower(value_);
      if (lower == "true" || lower == "false") {
        return std::unexpected(ResultError{"Cannot convert boolean value to integer type"});
      }
 
      // Use the appropriate parsing for the integer type
      try {
        if (!is_valid_integer(value_)) {
          return std::unexpected(ResultError{"Cannot convert to integer: invalid format"});
        }
 
        if constexpr (std::is_same_v<T, int>) {
          return std::stoi(value_);
        } else if constexpr (std::is_same_v<T, long>) {
          return std::stol(value_);
        } else if constexpr (std::is_same_v<T, long long>) {
          return std::stoll(value_);
        }
      } catch (const std::exception& e) {
        return std::unexpected(ResultError{std::string("Error parsing cell value '") + value_ +
                                           "' to integer: " + e.what()});
      }
    } else if constexpr (schema::ColumnTypeConcept<T>) {
      try {
        return schema::column_traits<T>::from_sql_string(value_);
      } catch (const std::exception& e) {
        return std::unexpected(ResultError{std::string("Error parsing cell value '") + value_ +
                                           "' to column type: " + e.what()});
      }
    } else {
      // Use appropriate parsing based on the target type
      return parse_value<T>(allow_numeric_bools);
    }
  }
 
private:
  std::string value_;
 
  // Helper to detect optional types
  template <typename T>
  static constexpr bool is_optional_v = false;
 
  // String helpers
  static std::string to_lower(std::string str) {
    std::transform(str.begin(), str.end(), str.begin(),
                   [](unsigned char c) { return std::tolower(c); });
    return str;
  }
 
  // Check if a value is likely a boolean
  static bool is_boolean_value(const std::string& str) {
    // Only accept "true", "false", "0", or "1" as possible boolean values
    return str == "true" || str == "false" || str == "0" || str == "1";
  }
 
  // Type-specific parsing implementations
  template <typename T>
  ResultProcessingResult<T> parse_value(bool allow_numeric_bools) const {
    try {
      if constexpr (std::is_same_v<T, int>) {
        // Validate the string contains only digits and optional sign
        if (!is_valid_integer(value_)) {
          return std::unexpected(ResultError{"Cannot convert to int: invalid format"});
        }
        return std::stoi(value_);
      } else if constexpr (std::is_same_v<T, long>) {
        if (!is_valid_integer(value_)) {
          return std::unexpected(ResultError{"Cannot convert to long: invalid format"});
        }
        return std::stol(value_);
      } else if constexpr (std::is_same_v<T, long long>) {
        if (!is_valid_integer(value_)) {
          return std::unexpected(ResultError{"Cannot convert to long long: invalid format"});
        }
        return std::stoll(value_);
      } else if constexpr (std::is_same_v<T, unsigned long>) {
        if (!is_valid_unsigned_integer(value_)) {
          return std::unexpected(ResultError{"Cannot convert to unsigned long: invalid format"});
        }
        return std::stoul(value_);
      } else if constexpr (std::is_same_v<T, unsigned long long>) {
        if (!is_valid_unsigned_integer(value_)) {
          return std::unexpected(
              ResultError{"Cannot convert to unsigned long long: invalid format"});
        }
        return std::stoull(value_);
      } else if constexpr (std::is_same_v<T, float>) {
        if (!is_valid_float(value_)) {
          return std::unexpected(ResultError{"Cannot convert to float: invalid format"});
        }
        return std::stof(value_);
      } else if constexpr (std::is_same_v<T, double>) {
        if (!is_valid_float(value_)) {
          return std::unexpected(ResultError{"Cannot convert to double: invalid format"});
        }
        return std::stod(value_);
      } else if constexpr (std::is_same_v<T, long double>) {
        if (!is_valid_float(value_)) {
          return std::unexpected(ResultError{"Cannot convert to long double: invalid format"});
        }
        return std::stold(value_);
      } else if constexpr (std::is_same_v<T, std::string>) {
        return value_;
      } else if constexpr (is_optional_v<T>) {
        using ValueType = typename T::value_type;
        auto result = as<ValueType>(allow_numeric_bools);
        if (result) {
          return T{*result};
        }
        return T{std::nullopt};
      } else {
        // For any other type, throw a clear conversion error
        return std::unexpected(
            ResultError{std::string("Unsupported type conversion from '") + value_ + "'"});
      }
    } catch (const std::exception& e) {
      return std::unexpected(
          ResultError{std::string("Error parsing cell value '") + value_ + "': " + e.what()});
    }
  }
 
  // Helper functions for validation
  static bool is_valid_integer(const std::string& str) {
    if (str.empty()) {
      return false;
    }
 
    size_t start = 0;
    if (str[0] == '-' || str[0] == '+') {
      start = 1;
    }
 
    return str.length() > start && std::all_of(str.begin() + static_cast<std::ptrdiff_t>(start),
                                               str.end(), [](char c) { return std::isdigit(c); });
  }
 
  static bool is_valid_unsigned_integer(const std::string& str) {
    if (str.empty()) {
      return false;
    }
 
    size_t start = 0;
    if (str[0] == '+') {
      start = 1;
    }
 
    return str.length() > start && std::all_of(str.begin() + static_cast<std::ptrdiff_t>(start),
                                               str.end(), [](char c) { return std::isdigit(c); });
  }
 
  static bool is_valid_float(const std::string& str) {
    if (str.empty()) {
      return false;
    }
 
    bool has_digit = false;
    bool has_decimal = false;
    bool has_exponent = false;
 
    size_t i = 0;
    if (str[0] == '-' || str[0] == '+') {
      i++;
    }
 
    for (; i < str.length(); i++) {
      const char c = str[i];
 
      if (std::isdigit(c)) {
        has_digit = true;
      } else if (c == '.') {
        if (has_decimal || has_exponent) {
          return false;
        }
        has_decimal = true;
      } else if (c == 'e' || c == 'E') {
        if (!has_digit || has_exponent) {
          return false;
        }
        has_exponent = true;
 
        if (i + 1 < str.length() && (str[i + 1] == '+' || str[i + 1] == '-')) {
          i++;
        }
        if (i + 1 >= str.length()) {
          return false;  // No digits after exponent
        }
      } else {
        return false;
      }
    }
 
    return has_digit;
  }
 
  // Specialization for optional types
  template <typename T>
  ResultProcessingResult<std::optional<T>> parse_value(bool allow_numeric_bools) const
    requires requires { parse_value<T>(allow_numeric_bools); }
  {
    if (is_null()) {
      return std::optional<T>{std::nullopt};
    }
 
    auto result = parse_value<T>(allow_numeric_bools);
    if (!result) {
      return std::unexpected(result.error());
    }
    return std::optional<T>{*result};
  }
};
 
// Specialization for Cell::is_optional_v
template <typename T>
constexpr bool Cell::is_optional_v<std::optional<T>> = true;
 
class Row {
public:
  explicit Row(std::vector<Cell> cells, std::vector<std::string> column_names = {})
      : cells_(std::move(cells)), column_names_(std::move(column_names)) {}
 
  ResultProcessingResult<const Cell*> get_cell(size_t index) const {
    if (index >= cells_.size()) {
      return std::unexpected(ResultError{"Cell index out of range"});
    }
    return &cells_[index];
  }
 
  ResultProcessingResult<const Cell*> get_cell(const std::string& name) const {
    if (column_names_.empty()) {
      return std::unexpected(ResultError{"Column names not available"});
    }
 
    for (size_t i = 0; i < column_names_.size(); ++i) {
      if (column_names_[i] == name && i < cells_.size()) {
        return &cells_[i];
      }
      if (column_names_[i] == name) {
        // Found the column name but missing the corresponding cell
        return std::unexpected(ResultError{"Column found but missing cell data: " + name});
      }
    }
 
    return std::unexpected(ResultError{"Column name not found: " + name});
  }
 
  template <typename T>
  ResultProcessingResult<T> get(size_t index) const {
    return get<T>(index, false);
  }
 
  template <typename T>
  ResultProcessingResult<T> get(size_t index, bool allow_numeric_bools) const {
    auto cell = get_cell(index);
    if (!cell) {
      return std::unexpected(cell.error());
    }
    return (*cell)->template as<T>(allow_numeric_bools);
  }
 
  template <typename T>
  ResultProcessingResult<T> get(const std::string& name) const {
    return get<T>(name, false);
  }
 
  template <typename T>
  ResultProcessingResult<T> get(const std::string& name, bool allow_numeric_bools) const {
    auto cell = get_cell(name);
    if (!cell) {
      return std::unexpected(cell.error());
    }
    return (*cell)->template as<T>(allow_numeric_bools);
  }
 
  template <typename T, typename ColType>
  ResultProcessingResult<T> get(const ColType& column) const {
    return get<T>(column, false);
  }
 
  template <typename T, typename ColType>
  ResultProcessingResult<T> get(const ColType& column, bool allow_numeric_bools) const {
    if constexpr (requires {
                    { column.column_name } -> std::convertible_to<std::string_view>;
                  }) {
      // If we have a column object with a column_name, use that
      return get<T>(std::string(column.column_name), allow_numeric_bools);
    } else if constexpr (requires {
                           { column.name } -> std::convertible_to<std::string_view>;
                         }) {
      // Some column-like objects might use 'name' instead
      return get<T>(std::string(column.name), allow_numeric_bools);
    } else if constexpr (std::is_same_v<ColType, std::string> ||
                         std::is_same_v<ColType, std::string_view> ||
                         std::is_convertible_v<ColType, std::string_view>) {
      // If we have a string, string_view, or convertible to string_view (like char array), use that
      // directly
      return get<T>(std::string(column), allow_numeric_bools);
    } else if constexpr (std::is_convertible_v<ColType, size_t>) {
      // If we can convert to size_t, use as an index
      return get<T>(static_cast<size_t>(column), allow_numeric_bools);
    } else {
      // For other custom column types
      static_assert(
          requires {
            { column } -> std::convertible_to<std::string_view>;
          } ||
              requires {
                { column } -> std::convertible_to<size_t>;
              } ||
              requires {
                { column.name } -> std::convertible_to<std::string_view>;
              } ||
              requires {
                { column.column_name } -> std::convertible_to<std::string_view>;
              },
          "Column must be convertible to a string, size_t, or have a name/column_name member");
 
      // This should never be reached due to the static_assert above
      return std::unexpected(ResultError{"Invalid column type"});
    }
  }
 
  template <auto MemberPtr>
  auto get() const {
    using Class = query::class_of_t_t<decltype(MemberPtr)>;
    using ColumnType = std::remove_reference_t<decltype(std::declval<Class>().*MemberPtr)>;
    using ValueType = typename ColumnType::value_type;
 
    // Find the column name
    static constexpr auto column_name = ColumnType::name;
 
    // Delegate to the string-based version
    return get<ValueType>(std::string(column_name));
  }
 
  template <auto MemberPtr>
  auto get_optional() const {
    using Class = query::class_of_t_t<decltype(MemberPtr)>;
    using ColumnType = std::remove_reference_t<decltype(std::declval<Class>().*MemberPtr)>;
    using ValueType = typename ColumnType::value_type;
 
    // Find the column name
    static constexpr auto column_name = ColumnType::name;
 
    // Delegate to the string-based version
    return get<std::optional<ValueType>>(std::string(column_name));
  }
 
  size_t size() const { return cells_.size(); }
 
  const std::vector<std::string>& column_names() const { return column_names_; }
 
  std::string to_string() const {
    std::stringstream result;
    result << "| ";
    for (const auto& cell : cells_) {
      result << cell.raw_value() << " | ";
    }
    return result.str();
  }
 
private:
  std::vector<Cell> cells_;
  std::vector<std::string> column_names_;
};
 
template <typename... Types>
struct RowAdapter {
  // Store the actual tuple of values
  std::tuple<Types...> values;
 
  // Allow direct access to elements for destructuring
  template <size_t I>
  friend const auto& get(const RowAdapter& a) {
    return std::get<I>(a.values);
  }
};
 
template <typename ResultSet, typename... Types>
struct RowIterator {
  const ResultSet& results;
  size_t index;
  std::array<size_t, sizeof...(Types)> column_indices;
 
  bool operator!=(const RowIterator& other) const { return index != other.index; }
 
  RowIterator& operator++() {
    ++index;
    return *this;
  }
 
  auto operator*() const { return get_row_values(std::make_index_sequence<sizeof...(Types)>{}); }
 
private:
  template <size_t... Indices>
  RowAdapter<Types...> get_row_values(std::index_sequence<Indices...>) const {
    const auto& row = results.at(index);
 
    return RowAdapter<Types...>{
        std::tuple<Types...>{[&row, this]() -> std::tuple_element_t<Indices, std::tuple<Types...>> {
          using ResultType = std::tuple_element_t<Indices, std::tuple<Types...>>;
          // Allow numeric boolean conversion for structured binding
          bool allow_numeric_bools = std::is_same_v<ResultType, bool>;
          auto result = row.template get<ResultType>(column_indices[Indices], allow_numeric_bools);
          if (result) {
            return *result;
          }
          // Return default value for the type if conversion fails
          return ResultType{};
        }()...}};
  }
};
 
template <typename ResultSet, typename... Types>
struct RowsView {
  const ResultSet& results;
  std::array<size_t, sizeof...(Types)> column_indices;
 
  RowIterator<ResultSet, Types...> begin() const { return {results, 0, column_indices}; }
 
  RowIterator<ResultSet, Types...> end() const { return {results, results.size(), column_indices}; }
};
 
class ResultSet {
public:
  ResultSet() = default;
 
  ResultSet(std::vector<Row> rows, std::vector<std::string> column_names = {})
      : rows_(std::move(rows)), column_names_(std::move(column_names)) {}
 
  size_t size() const { return rows_.size(); }
 
  bool empty() const { return rows_.empty(); }
 
  const Row& at(size_t index) const { return rows_.at(index); }
 
  const Row& operator[](size_t index) const { return rows_.at(index); }
 
  size_t column_count() const { return column_names_.size(); }
 
  ResultProcessingResult<std::string> column_name(size_t index) const {
    if (index >= column_names_.size()) {
      return std::unexpected(ResultError{"Column index out of range"});
    }
    return column_names_.at(index);
  }
 
  const std::vector<std::string>& column_names() const { return column_names_; }
 
  auto begin() const { return rows_.begin(); }
 
  auto end() const { return rows_.end(); }
 
  template <typename T>
  std::vector<T> transform(std::function<ResultProcessingResult<T>(const Row&)> mapper) const {
    std::vector<T> result;
    result.reserve(rows_.size());
 
    for (const auto& row : rows_) {
      auto transformed = mapper(row);
      if (transformed) {
        result.push_back(std::move(*transformed));
      }
    }
 
    return result;
  }
 
  template <typename... Types>
  auto as() const {
    // Default to first N columns where N is the number of Types
    std::array<size_t, sizeof...(Types)> indices;
    for (size_t i = 0; i < sizeof...(Types); ++i) {
      indices[i] = i;
    }
    return as<Types...>(indices);
  }
 
  template <typename... Types>
  auto as(const std::array<size_t, sizeof...(Types)>& indices) const {
    return RowsView<ResultSet, Types...>{*this, indices};
  }
 
  template <typename... Types>
  auto as(const std::array<std::string, sizeof...(Types)>& column_names) const {
    std::array<size_t, sizeof...(Types)> indices;
 
    for (size_t i = 0; i < sizeof...(Types); ++i) {
      bool found = false;
      for (size_t col_idx = 0; col_idx < column_names_.size(); ++col_idx) {
        if (column_names_[col_idx] == column_names[i]) {
          indices[i] = col_idx;
          found = true;
          break;
        }
      }
      if (!found) {
        // If column name not found, default to index or 0
        indices[i] = (i < column_names_.size()) ? i : 0;
      }
    }
 
    return as<Types...>(indices);
  }
 
  template <typename Table, typename P1, typename... Ps>
    requires schema::TableConcept<Table>
  auto with_schema(P1 mp1, Ps... mps) const {
    constexpr size_t num_cols = 1 + sizeof...(Ps);
    std::array<std::string, num_cols> column_names;
 
    // Fill the column names array using our helper
    column_names[0] = get_column_name_from_ptr<Table>(mp1);
    if constexpr (sizeof...(Ps) > 0) {
      size_t i = 1;
      ((column_names[i++] = get_column_name_from_ptr<Table>(mps)), ...);
    }
 
    // Call the as<> method with the right types
    return as<column_member_value_t<Table, P1>, column_member_value_t<Table, Ps>...>(column_names);
  }
 
  template <typename Table, typename P1, typename... Ps>
    requires schema::TableConcept<std::remove_reference_t<Table>>
  auto with_schema(const Table& /*table*/, P1 mp1, Ps... mps) const {
    return with_schema<std::remove_reference_t<Table>>(mp1, mps...);
  }
 
  std::string to_string() const {
    std::string result;
    for (const auto& row : rows_) {
      result += row.to_string();
      std::cout << '\n';
    }
    return result;
  }
 
private:
  std::vector<Row> rows_;
  std::vector<std::string> column_names_;
};
 
template <query::SqlExpr Query>
ResultProcessingResult<ResultSet> parse(const Query& /*query*/, const std::string& raw_results) {
  try {
    // Split the raw results into lines
    std::vector<std::string> lines;
    size_t pos = 0;
    size_t next_pos = 0;
 
    // Parse header line and data lines
    while ((next_pos = raw_results.find('\n', pos)) != std::string::npos) {
      lines.push_back(raw_results.substr(pos, next_pos - pos));
      pos = next_pos + 1;
    }
 
    // Add the last line if it's not empty
    if (pos < raw_results.size()) {
      lines.push_back(raw_results.substr(pos));
    }
 
    if (lines.empty()) {
      return ResultSet{};
    }
 
    // Parse column names from the first line
    std::vector<std::string> column_names;
    const std::string header = lines[0];
    pos = 0;
 
    while ((next_pos = header.find('|', pos)) != std::string::npos) {
      column_names.push_back(header.substr(pos, next_pos - pos));
      pos = next_pos + 1;
    }
 
    // Add the last column
    if (pos < header.size()) {
      column_names.push_back(header.substr(pos));
    }
 
    // Parse data rows
    std::vector<Row> rows;
 
    for (size_t i = 1; i < lines.size(); ++i) {
      const auto& line = lines[i];
 
      // Skip empty lines
      if (line.empty()) {
        continue;
      }
 
      // Parse cells
      std::vector<Cell> cells;
      pos = 0;
 
      while ((next_pos = line.find('|', pos)) != std::string::npos) {
        cells.emplace_back(line.substr(pos, next_pos - pos));
        pos = next_pos + 1;
      }
 
      // Add the last cell
      if (pos < line.size()) {
        cells.emplace_back(line.substr(pos));
      }
 
      // Create a row with the cells and column names
      rows.emplace_back(std::move(cells), column_names);
    }
 
    return ResultSet{std::move(rows), std::move(column_names)};
  } catch (const std::exception& e) {
    return std::unexpected(ResultError{std::string("Error parsing results: ") + e.what()});
  }
}
 
}  // namespace relx::result
 
// Structured binding support
namespace std {
template <typename... Types>
struct tuple_size<relx::result::RowAdapter<Types...>>
    : std::integral_constant<size_t, sizeof...(Types)> {};
 
template <size_t I, typename... Types>
struct tuple_element<I, relx::result::RowAdapter<Types...>> {
  using type = std::tuple_element_t<I, std::tuple<Types...>>;
};
}  // namespace std
 
// Include lazy and streaming functionality
#include "lazy_result.hpp"
#include "streaming_result.hpp"