core.hpp

Go to the documentation of this file.

#pragma once
 
#include "../schema/column.hpp"
#include "../schema/core.hpp"
#include "../schema/table.hpp"
 
#include <concepts>
#include <expected>
#include <ranges>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace relx::query {
 
struct QueryError {
  std::string message;
};
 
template <typename T>
using QueryResult = std::expected<T, QueryError>;
 
template <typename T>
concept SqlExpr = requires(T t) {
  { t.to_sql() } -> std::convertible_to<std::string>;
  { t.bind_params() } -> std::ranges::range;
};
 
template <typename T>
concept TableType = schema::TableConcept<T>;
 
template <typename T>
concept ColumnType = requires(T t) {
  { T::name } -> std::convertible_to<std::string_view>;
  typename T::value_type;
};
 
template <typename T>
concept ColumnList = std::ranges::range<T> && requires {
  typename std::ranges::range_value_t<T>;
} && ColumnType<std::remove_cvref_t<std::ranges::range_value_t<T>>>;
 
template <typename T>
concept TableList = std::ranges::range<T> && requires { typename std::ranges::range_value_t<T>; } &&
                    TableType<std::remove_cvref_t<std::ranges::range_value_t<T>>>;
 
template <typename T>
concept ConditionExpr = SqlExpr<T>;
 
struct SqlExpression {
  virtual ~SqlExpression() = default;
  virtual std::string to_sql() const = 0;
  virtual std::vector<std::string> bind_params() const = 0;
};
 
enum class JoinType { Inner, Left, Right, Full, Cross };
 
inline std::string join_type_to_string(JoinType type) {
  switch (type) {
  case JoinType::Inner:
    return "INNER JOIN";
  case JoinType::Left:
    return "LEFT JOIN";
  case JoinType::Right:
    return "RIGHT JOIN";
  case JoinType::Full:
    return "FULL JOIN";
  case JoinType::Cross:
    return "CROSS JOIN";
  default:
    return "JOIN";
  }
}
 
}  // namespace relx::query