value.hpp

Go to the documentation of this file.

#pragma once
 
#include "core.hpp"
 
#include <optional>
#include <sstream>
#include <string>
#include <vector>
 
namespace relx::query {
 
template <typename T>
class Value : public SqlExpression {
public:
  using value_type = T;
 
  explicit Value(T value) : value_(std::move(value)) {}
 
  std::string to_sql() const override { return "?"; }
 
  std::vector<std::string> bind_params() const override {
    return {schema::column_traits<T>::to_sql_string(value_)};
  }
 
  const T& value() const { return value_; }
 
private:
  T value_;
};
 
template <typename T>
class Value<std::optional<T>> : public SqlExpression {
public:
  using value_type = std::optional<T>;
 
  explicit Value(std::optional<T> value) : value_(std::move(value)) {}
 
  std::string to_sql() const override {
    if (value_.has_value()) {
      return "?";
    }
    return "NULL";
  }
 
  std::vector<std::string> bind_params() const override {
    if (value_.has_value()) {
      return {schema::column_traits<T>::to_sql_string(*value_)};
    }
    return {};
  }
 
  const std::optional<T>& value() const { return value_; }
 
private:
  std::optional<T> value_;
};
 
template <>
class Value<std::string> : public SqlExpression {
public:
  using value_type = std::string;
 
  explicit Value(std::string value) : value_(std::move(value)) {}
 
  std::string to_sql() const override { return "?"; }
 
  std::vector<std::string> bind_params() const override { return {value_}; }
 
  const std::string& value() const { return value_; }
 
private:
  std::string value_;
};
 
template <>
class Value<std::string_view> : public SqlExpression {
public:
  using value_type = std::string_view;
 
  explicit Value(std::string_view value) : value_(value) {}
 
  std::string to_sql() const override { return "?"; }
 
  std::vector<std::string> bind_params() const override { return {std::string(value_)}; }
 
  std::string_view value() const { return value_; }
 
private:
  std::string_view value_;
};
 
template <>
class Value<const char*> : public SqlExpression {
public:
  using value_type = const char*;
 
  explicit Value(const char* value) : value_(value) {}
 
  std::string to_sql() const override { return "?"; }
 
  std::vector<std::string> bind_params() const override { return {std::string(value_)}; }
 
  const char* value() const { return value_; }
 
private:
  const char* value_;
};
 
template <typename T>
auto value(T val) {
  return Value<T>(std::move(val));
}
 
inline auto val(const char* str) {
  return Value<std::string_view>(str);
}
 
inline auto val(std::string str) {
  return Value<std::string>(std::move(str));
}
 
inline auto val(std::string_view sv) {
  return Value<std::string_view>(sv);
}
 
inline auto val(int i) {
  return Value<int>(i);
}
 
inline auto val(long l) {
  return Value<long>(l);
}
 
inline auto val(long long ll) {
  return Value<long long>(ll);
}
 
inline auto val(double d) {
  return Value<double>(d);
}
 
inline auto val(float f) {
  return Value<float>(f);
}
 
inline auto val(bool b) {
  return Value<bool>(b);
}
 
template <typename T>
auto val(std::optional<T> opt) {
  return Value<std::optional<T>>(std::move(opt));
}
 
inline auto val(std::nullopt_t) {
  return Value<std::nullopt_t>(std::nullopt);
}
 
}  // namespace relx::query