column.hpp

Go to the documentation of this file.

#pragma once
 
#include "core.hpp"
#include "fixed_string.hpp"
 
#include <optional>
#include <string_view>
#include <tuple>
#include <type_traits>
 
namespace relx::schema {
 
struct unique {
  static std::string to_sql() { return " UNIQUE"; }
};
 
struct primary_key {
  static std::string to_sql() { return " PRIMARY KEY"; }
};
 
struct autoincrement {
  static std::string to_sql() {
    // SQLite syntax
    return " AUTOINCREMENT";
  }
};
 
template <typename T>
concept ValidIdentityType = std::is_integral_v<T> && !std::is_same_v<T, bool>;
 
template <auto Start = 1, auto Increment = 1,
          auto MinValue = std::numeric_limits<decltype(Start)>::min(),
          auto MaxValue = std::numeric_limits<decltype(Start)>::max(), bool Cycle = false>
  requires ValidIdentityType<decltype(Start)> && ValidIdentityType<decltype(Increment)> &&
           ValidIdentityType<decltype(MinValue)> && ValidIdentityType<decltype(MaxValue)>
struct identity {
  static constexpr auto start = Start;
  static constexpr auto increment = Increment;
  static constexpr auto min_value = MinValue;
  static constexpr auto max_value = MaxValue;
  static constexpr bool cycle = Cycle;
 
  static std::string to_sql() {
    std::string result = " GENERATED ALWAYS AS IDENTITY";
 
    // Add options if they differ from defaults
    if constexpr (start != 1 || increment != 1 ||
                  min_value != std::numeric_limits<decltype(start)>::min() ||
                  max_value != std::numeric_limits<decltype(start)>::max() || cycle) {
      result += " (";
 
      // Add start value if not default
      if constexpr (start != 1) {
        result += "START WITH " + std::to_string(start);
      }
 
      // Add increment if not default
      if constexpr (increment != 1) {
        if constexpr (start != 1) {
          result += " ";
        }
        result += "INCREMENT BY " + std::to_string(increment);
      }
 
      // Add min value if not default
      if constexpr (min_value != std::numeric_limits<decltype(start)>::min()) {
        if constexpr (start != 1 || increment != 1) {
          result += " ";
        }
        result += "MINVALUE " + std::to_string(min_value);
      }
 
      // Add max value if not default
      if constexpr (max_value != std::numeric_limits<decltype(start)>::max()) {
        if constexpr (start != 1 || increment != 1 ||
                      min_value != std::numeric_limits<decltype(start)>::min()) {
          result += " ";
        }
        result += "MAXVALUE " + std::to_string(max_value);
      }
 
      // Add cycle option if true
      if constexpr (cycle) {
        if constexpr (start != 1 || increment != 1 ||
                      min_value != std::numeric_limits<decltype(start)>::min() ||
                      max_value != std::numeric_limits<decltype(start)>::max()) {
          result += " ";
        }
        result += "CYCLE";
      }
 
      result += ")";
    }
 
    return result;
  }
};
 
template <fixed_string Expr>
struct check {
  static constexpr auto expr = Expr;
 
  static std::string to_sql() { return " CHECK(" + std::string(std::string_view(expr)) + ")"; }
};
 
template <fixed_string Table, fixed_string Column>
struct references {
  static constexpr auto table = Table;
  static constexpr auto column = Column;
 
  static std::string to_sql() {
    return " REFERENCES " + std::string(std::string_view(table)) + "(" +
           std::string(std::string_view(column)) + ")";
  }
};
 
template <fixed_string Action>
struct on_delete {
  static constexpr auto action = Action;
 
  static std::string to_sql() { return " ON DELETE " + std::string(std::string_view(action)); }
};
 
template <fixed_string Action>
struct on_update {
  static constexpr auto action = Action;
 
  static std::string to_sql() { return " ON UPDATE " + std::string(std::string_view(action)); }
};
 
template <auto Value>
struct default_value {
  using value_type = decltype(Value);
 
  static constexpr value_type value = Value;
 
  static std::string to_sql() {
    if constexpr (std::is_same_v<value_type, bool>) {
      // For boolean values, use true/false in SQL
      return " DEFAULT " + std::string(value ? "true" : "false");
    } else if constexpr (std::is_integral_v<value_type> || std::is_floating_point_v<value_type>) {
      // For numeric types, convert to string
      return " DEFAULT " + std::to_string(value);
    } else {
      // Fall back to generic string conversion
      return " DEFAULT " + std::to_string(value);
    }
  }
};
 
template <fixed_string Value, bool IsLiteral = false>
struct string_default {
  static constexpr auto value = Value;
 
  static std::string to_sql() {
    if constexpr (IsLiteral) {
      // SQL function or literal that should not be quoted
      return " DEFAULT " + std::string(std::string_view(value));
    } else {
      // Normal string that should be quoted
      return " DEFAULT '" + std::string(std::string_view(value)) + "'";
    }
  }
};
 
struct null_default {
  static std::string to_sql() { return " DEFAULT NULL"; }
};
 
template <typename... Modifiers>
static std::string apply_modifiers() {
  std::string result;
  [[maybe_unused]] auto _ = (result += ... += Modifiers::to_sql());  // supress unused warning
  return result;
}
 
// Type trait to detect default_value specialization
template <typename TypeParam>
struct is_default_value_specialization : std::false_type {};
 
template <auto Value>
struct is_default_value_specialization<default_value<Value>> : std::true_type {
  using value_type = decltype(Value);
};
 
// Type trait to detect string_default specialization
template <typename TypeParam>
struct is_string_default_specialization : std::false_type {};
 
template <fixed_string Value, bool IsLiteral>
struct is_string_default_specialization<string_default<Value, IsLiteral>> : std::true_type {};
 
template <typename TableT, fixed_string Name, typename T, typename... Modifiers>
class column {
public:
  using table_type = TableT;
 
  using value_type = T;
 
  static constexpr auto name = Name;
 
  static constexpr auto sql_type = column_traits<T>::sql_type_name;
 
  static constexpr bool nullable = column_traits<T>::nullable;
 
  std::string sql_definition() const {
    std::string result = std::string(std::string_view(name)) + " " +
                         std::string(std::string_view(sql_type));
 
    // Add NOT NULL if not nullable
    if (!nullable) {
      result += " NOT NULL";
    }
 
    // Apply all modifiers
    result += apply_modifiers<Modifiers...>();
 
    return result;
  }
 
  static std::string to_sql_string(const T& value) {
    return column_traits<T>::to_sql_string(value);
  }
 
  static T from_sql_string(const std::string& sql_str) {
    return column_traits<T>::from_sql_string(sql_str);
  }
 
  std::optional<T> get_default_value() const { return find_default_value<T, Modifiers...>(); }
 
  template <typename PatternType>
    requires std::convertible_to<PatternType, std::string>
  auto like(PatternType&& pattern) const;
 
  auto is_null() const;
 
  auto is_not_null() const;
 
private:
  // Helper to find default value in the modifiers
  template <typename ValueT, typename First, typename... Rest>
  static std::optional<ValueT> find_default_value() {
    if constexpr (is_default_value_type<First, ValueT>()) {
      return extract_default_value<First, ValueT>();
    } else if constexpr (sizeof...(Rest) > 0) {
      return find_default_value<ValueT, Rest...>();
    } else {
      return std::nullopt;
    }
  }
 
  template <typename ValueT>
  static std::optional<ValueT> find_default_value() {
    return std::nullopt;
  }
 
  // Check if a type is a default value type
  template <typename Mod, typename ValueT>
  static constexpr bool is_default_value_type() {
    if constexpr (std::is_same_v<Mod, null_default>) {
      return column_traits<ValueT>::nullable;
    } else if constexpr (is_default_value_specialization<Mod>::value) {
      using DefaultValueType = typename is_default_value_specialization<Mod>::value_type;
      return std::is_same_v<DefaultValueType, ValueT> ||
             std::is_convertible_v<DefaultValueType, ValueT>;
    } else if constexpr (is_string_default_specialization<Mod>::value) {
      if constexpr (std::is_same_v<ValueT, std::string> ||
                    std::is_convertible_v<std::string, ValueT> ||
                    std::is_constructible_v<ValueT, std::string_view> ||
                    std::is_constructible_v<ValueT, const char*>) {
        return true;
      } else {
        return false;
      }
    } else {
      return false;
    }
  }
 
  // Extract the default value from a modifier
  template <typename Mod, typename ValueT>
  static std::optional<ValueT> extract_default_value() {
    if constexpr (std::is_same_v<Mod, null_default>) {
      if constexpr (column_traits<ValueT>::nullable) {
        return std::nullopt;
      }
    } else if constexpr (is_default_value_specialization<Mod>::value) {
      return static_cast<ValueT>(Mod::value);
    } else if constexpr (is_string_default_specialization<Mod>::value) {
      if constexpr (std::is_constructible_v<ValueT, std::string_view>) {
        return ValueT(std::string_view(Mod::value));
      } else if constexpr (std::is_constructible_v<ValueT, std::string>) {
        return ValueT(std::string(std::string_view(Mod::value)));
      } else if constexpr (std::is_constructible_v<ValueT, const char*>) {
        return ValueT(Mod::value.data());
      }
    }
    return std::nullopt;
  }
};
 
// Specialization for std::optional columns (nullable)
template <typename TableT, fixed_string Name, typename T, typename... Modifiers>
class column<TableT, Name, std::optional<T>, Modifiers...> {
public:
  using table_type = TableT;
 
  using value_type = std::optional<T>;
  using base_type = T;
 
  static constexpr auto name = Name;
  static constexpr auto sql_type = column_traits<T>::sql_type_name;
  static constexpr bool nullable = true;
 
  std::string sql_definition() const {
    std::string result = std::string(std::string_view(name)) + " " +
                         std::string(std::string_view(sql_type));
 
    // No NOT NULL constraint for optional columns
 
    // Apply all modifiers
    result += apply_modifiers<Modifiers...>();
 
    return result;
  }
 
  static std::string to_sql_string(const std::optional<T>& value) {
    if (value.has_value()) {
      return column_traits<T>::to_sql_string(*value);
    }
    return "NULL";
  }
 
  static std::optional<T> from_sql_string(const std::string& sql_str) {
    if (sql_str == "NULL") {
      return std::nullopt;
    }
    return column_traits<T>::from_sql_string(sql_str);
  }
 
  std::optional<std::optional<T>> get_default_value() const {
    return find_default_value<std::optional<T>, Modifiers...>();
  }
 
  template <typename PatternType>
    requires std::convertible_to<PatternType, std::string>
  auto like(PatternType&& pattern) const;
 
  auto is_null() const;
 
  auto is_not_null() const;
 
private:
  // Helper to find default value in the modifiers
  template <typename ValueT, typename First, typename... Rest>
  static std::optional<ValueT> find_default_value() {
    if constexpr (is_default_value_type<First, ValueT>()) {
      return extract_default_value<First, ValueT>();
    } else if constexpr (sizeof...(Rest) > 0) {
      return find_default_value<ValueT, Rest...>();
    } else {
      return std::nullopt;
    }
  }
 
  template <typename ValueT>
  static std::optional<ValueT> find_default_value() {
    return std::nullopt;
  }
 
  // Check if a type is a default value type
  template <typename Mod, typename ValueT>
  static constexpr bool is_default_value_type() {
    if constexpr (std::is_same_v<Mod, null_default>) {
      return true;  // null_default is valid for std::optional<T>
    } else if constexpr (is_default_value_specialization<Mod>::value) {
      using DefaultValueType = typename is_default_value_specialization<Mod>::value_type;
      using OptionalBaseType = typename ValueT::value_type;
      return std::is_same_v<DefaultValueType, OptionalBaseType> ||
             std::is_convertible_v<DefaultValueType, OptionalBaseType>;
    } else if constexpr (is_string_default_specialization<Mod>::value) {
      using OptionalBaseType = typename ValueT::value_type;
      return std::is_convertible_v<std::string_view, OptionalBaseType>;
    } else {
      return false;
    }
  }
 
  // Extract the default value from a modifier
  template <typename Mod, typename ValueT>
  static std::optional<ValueT> extract_default_value() {
    if constexpr (std::is_same_v<Mod, null_default>) {
      if constexpr (column_traits<ValueT>::nullable) {
        return std::nullopt;
      }
    } else if constexpr (is_default_value_specialization<Mod>::value) {
      return static_cast<ValueT>(Mod::value);
    } else if constexpr (is_string_default_specialization<Mod>::value) {
      if constexpr (std::is_constructible_v<ValueT, std::string_view>) {
        return ValueT(std::string_view(Mod::value));
      } else if constexpr (std::is_constructible_v<ValueT, std::string>) {
        return ValueT(std::string(std::string_view(Mod::value)));
      } else if constexpr (std::is_constructible_v<ValueT, const char*>) {
        return ValueT(Mod::value.data());
      }
    }
    return std::nullopt;
  }
};
 
}  // namespace relx::schema