date.hpp

Go to the documentation of this file.

#pragma once
 
#include "../schema/column.hpp"
#include "arithmetic.hpp"
#include "column_expression.hpp"
#include "condition.hpp"
#include "core.hpp"
#include "date_concepts.hpp"
#include "function.hpp"
#include "value.hpp"
 
#include <chrono>
#include <concepts>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace relx::query {
 
template <SqlExpr Left, SqlExpr Right>
class BinaryDateFunctionExpr : public ColumnExpression {
public:
  BinaryDateFunctionExpr(std::string func_name, std::string unit, Left left, Right right)
      : func_name_(std::move(func_name)), unit_(std::move(unit)), left_(std::move(left)),
        right_(std::move(right)) {}
 
  std::string to_sql() const override {
    // Generate PostgreSQL-compatible SQL for date differences
    if (func_name_ == "DATE_DIFF") {
      if (unit_ == "year") {
        return "EXTRACT(YEAR FROM AGE(" + right_.to_sql() + ", " + left_.to_sql() + "))";
      } else if (unit_ == "day") {
        // For PostgreSQL, handle date vs timestamp arithmetic properly
        // If we're dealing with timestamps, convert to date difference in days
        // If we're dealing with dates, simple subtraction works
        return "(" + right_.to_sql() + "::date - " + left_.to_sql() + "::date)";
      } else if (unit_ == "second") {
        return "EXTRACT(EPOCH FROM (" + right_.to_sql() + " - " + left_.to_sql() + "))";
      } else if (unit_ == "month") {
        return "EXTRACT(MONTH FROM AGE(" + right_.to_sql() + ", " + left_.to_sql() + "))";
      } else if (unit_ == "hour") {
        return "EXTRACT(EPOCH FROM (" + right_.to_sql() + " - " + left_.to_sql() + "))/3600";
      } else if (unit_ == "minute") {
        return "EXTRACT(EPOCH FROM (" + right_.to_sql() + " - " + left_.to_sql() + "))/60";
      }
    }
    // Fallback to generic format for other functions
    return func_name_ + "('" + unit_ + "', " + left_.to_sql() + ", " + right_.to_sql() + ")";
  }
 
  std::vector<std::string> bind_params() const override {
    auto left_params = left_.bind_params();
    auto right_params = right_.bind_params();
    left_params.insert(left_params.end(), right_params.begin(), right_params.end());
    return left_params;
  }
 
  std::string column_name() const override { return func_name_ + "_" + unit_; }
 
  std::string table_name() const override {
    if constexpr (std::is_base_of_v<ColumnExpression, Left>) {
      auto table = left_.table_name();
      if (!table.empty()) {
        return table;
      }
    }
    if constexpr (std::is_base_of_v<ColumnExpression, Right>) {
      return right_.table_name();
    }
    return "";
  }
 
  // Operator overloads for comparisons with literals
  template <typename LiteralT>
    requires std::is_arithmetic_v<std::remove_cvref_t<LiteralT>> ||
             std::is_convertible_v<std::remove_cvref_t<LiteralT>, std::string>
  auto operator==(LiteralT&& literal) const {
    auto val_expr = val(std::forward<LiteralT>(literal));
    return BinaryCondition<BinaryDateFunctionExpr, decltype(val_expr)>(*this, "=", val_expr);
  }
 
  template <typename LiteralT>
    requires std::is_arithmetic_v<std::remove_cvref_t<LiteralT>> ||
             std::is_convertible_v<std::remove_cvref_t<LiteralT>, std::string>
  auto operator!=(LiteralT&& literal) const {
    auto val_expr = val(std::forward<LiteralT>(literal));
    return BinaryCondition<BinaryDateFunctionExpr, decltype(val_expr)>(*this, "!=", val_expr);
  }
 
  template <typename LiteralT>
    requires std::is_arithmetic_v<std::remove_cvref_t<LiteralT>> ||
             std::is_convertible_v<std::remove_cvref_t<LiteralT>, std::string>
  auto operator>(LiteralT&& literal) const {
    auto val_expr = val(std::forward<LiteralT>(literal));
    return BinaryCondition<BinaryDateFunctionExpr, decltype(val_expr)>(*this, ">", val_expr);
  }
 
  template <typename LiteralT>
    requires std::is_arithmetic_v<std::remove_cvref_t<LiteralT>> ||
             std::is_convertible_v<std::remove_cvref_t<LiteralT>, std::string>
  auto operator<(LiteralT&& literal) const {
    auto val_expr = val(std::forward<LiteralT>(literal));
    return BinaryCondition<BinaryDateFunctionExpr, decltype(val_expr)>(*this, "<", val_expr);
  }
 
  template <typename LiteralT>
    requires std::is_arithmetic_v<std::remove_cvref_t<LiteralT>> ||
             std::is_convertible_v<std::remove_cvref_t<LiteralT>, std::string>
  auto operator>=(LiteralT&& literal) const {
    auto val_expr = val(std::forward<LiteralT>(literal));
    return BinaryCondition<BinaryDateFunctionExpr, decltype(val_expr)>(*this, ">=", val_expr);
  }
 
  template <typename LiteralT>
    requires std::is_arithmetic_v<std::remove_cvref_t<LiteralT>> ||
             std::is_convertible_v<std::remove_cvref_t<LiteralT>, std::string>
  auto operator<=(LiteralT&& literal) const {
    auto val_expr = val(std::forward<LiteralT>(literal));
    return BinaryCondition<BinaryDateFunctionExpr, decltype(val_expr)>(*this, "<=", val_expr);
  }
 
  // Arithmetic operator overloads
  template <typename NumericT>
    requires std::is_arithmetic_v<std::remove_cvref_t<NumericT>>
  auto operator*(NumericT&& literal) const {
    auto val_expr = val(std::forward<NumericT>(literal));
    return ArithmeticExpr<BinaryDateFunctionExpr, decltype(val_expr)>(*this, "*", val_expr);
  }
 
  template <typename NumericT>
    requires std::is_arithmetic_v<std::remove_cvref_t<NumericT>>
  auto operator+(NumericT&& literal) const {
    auto val_expr = val(std::forward<NumericT>(literal));
    return ArithmeticExpr<BinaryDateFunctionExpr, decltype(val_expr)>(*this, "+", val_expr);
  }
 
  template <typename NumericT>
    requires std::is_arithmetic_v<std::remove_cvref_t<NumericT>>
  auto operator-(NumericT&& literal) const {
    auto val_expr = val(std::forward<NumericT>(literal));
    return ArithmeticExpr<BinaryDateFunctionExpr, decltype(val_expr)>(*this, "-", val_expr);
  }
 
  template <typename NumericT>
    requires std::is_arithmetic_v<std::remove_cvref_t<NumericT>>
  auto operator/(NumericT&& literal) const {
    auto val_expr = val(std::forward<NumericT>(literal));
    return ArithmeticExpr<BinaryDateFunctionExpr, decltype(val_expr)>(*this, "/", val_expr);
  }
 
private:
  std::string func_name_;
  std::string unit_;
  Left left_;
  Right right_;
};
 
template <SqlExpr Expr>
class UnaryDateFunctionExpr : public ColumnExpression {
public:
  UnaryDateFunctionExpr(std::string func_name, std::string unit, Expr expr)
      : func_name_(std::move(func_name)), unit_(std::move(unit)), expr_(std::move(expr)) {}
 
  std::string to_sql() const override {
    if (func_name_ == "EXTRACT") {
      return "EXTRACT(" + unit_ + " FROM " + expr_.to_sql() + ")";
    }
    if (func_name_ == "ABS") {
      return "ABS(" + expr_.to_sql() + ")";
    }
    return func_name_ + "('" + unit_ + "', " + expr_.to_sql() + ")";
  }
 
  std::vector<std::string> bind_params() const override { return expr_.bind_params(); }
 
  std::string column_name() const override { return func_name_ + "_" + unit_; }
 
  std::string table_name() const override {
    if constexpr (std::is_base_of_v<ColumnExpression, Expr>) {
      return expr_.table_name();
    }
    return "";
  }
 
  // Operator overloads for comparisons with literals
  template <typename LiteralT>
    requires std::is_arithmetic_v<std::remove_cvref_t<LiteralT>> ||
             std::is_convertible_v<std::remove_cvref_t<LiteralT>, std::string>
  auto operator==(LiteralT&& literal) const {
    auto val_expr = val(std::forward<LiteralT>(literal));
    return BinaryCondition<UnaryDateFunctionExpr, decltype(val_expr)>(*this, "=", val_expr);
  }
 
  template <typename LiteralT>
    requires std::is_arithmetic_v<std::remove_cvref_t<LiteralT>> ||
             std::is_convertible_v<std::remove_cvref_t<LiteralT>, std::string>
  auto operator!=(LiteralT&& literal) const {
    auto val_expr = val(std::forward<LiteralT>(literal));
    return BinaryCondition<UnaryDateFunctionExpr, decltype(val_expr)>(*this, "!=", val_expr);
  }
 
  template <typename LiteralT>
    requires std::is_arithmetic_v<std::remove_cvref_t<LiteralT>> ||
             std::is_convertible_v<std::remove_cvref_t<LiteralT>, std::string>
  auto operator>(LiteralT&& literal) const {
    auto val_expr = val(std::forward<LiteralT>(literal));
    return BinaryCondition<UnaryDateFunctionExpr, decltype(val_expr)>(*this, ">", val_expr);
  }
 
  template <typename LiteralT>
    requires std::is_arithmetic_v<std::remove_cvref_t<LiteralT>> ||
             std::is_convertible_v<std::remove_cvref_t<LiteralT>, std::string>
  auto operator<(LiteralT&& literal) const {
    auto val_expr = val(std::forward<LiteralT>(literal));
    return BinaryCondition<UnaryDateFunctionExpr, decltype(val_expr)>(*this, "<", val_expr);
  }
 
  template <typename LiteralT>
    requires std::is_arithmetic_v<std::remove_cvref_t<LiteralT>> ||
             std::is_convertible_v<std::remove_cvref_t<LiteralT>, std::string>
  auto operator>=(LiteralT&& literal) const {
    auto val_expr = val(std::forward<LiteralT>(literal));
    return BinaryCondition<UnaryDateFunctionExpr, decltype(val_expr)>(*this, ">=", val_expr);
  }
 
  template <typename LiteralT>
    requires std::is_arithmetic_v<std::remove_cvref_t<LiteralT>> ||
             std::is_convertible_v<std::remove_cvref_t<LiteralT>, std::string>
  auto operator<=(LiteralT&& literal) const {
    auto val_expr = val(std::forward<LiteralT>(literal));
    return BinaryCondition<UnaryDateFunctionExpr, decltype(val_expr)>(*this, "<=", val_expr);
  }
 
  // Arithmetic operator overloads
  template <typename NumericT>
    requires std::is_arithmetic_v<std::remove_cvref_t<NumericT>>
  auto operator*(NumericT&& literal) const {
    auto val_expr = val(std::forward<NumericT>(literal));
    return ArithmeticExpr<UnaryDateFunctionExpr, decltype(val_expr)>(*this, "*", val_expr);
  }
 
  template <typename NumericT>
    requires std::is_arithmetic_v<std::remove_cvref_t<NumericT>>
  auto operator+(NumericT&& literal) const {
    auto val_expr = val(std::forward<NumericT>(literal));
    return ArithmeticExpr<UnaryDateFunctionExpr, decltype(val_expr)>(*this, "+", val_expr);
  }
 
  template <typename NumericT>
    requires std::is_arithmetic_v<std::remove_cvref_t<NumericT>>
  auto operator-(NumericT&& literal) const {
    auto val_expr = val(std::forward<NumericT>(literal));
    return ArithmeticExpr<UnaryDateFunctionExpr, decltype(val_expr)>(*this, "-", val_expr);
  }
 
  template <typename NumericT>
    requires std::is_arithmetic_v<std::remove_cvref_t<NumericT>>
  auto operator/(NumericT&& literal) const {
    auto val_expr = val(std::forward<NumericT>(literal));
    return ArithmeticExpr<UnaryDateFunctionExpr, decltype(val_expr)>(*this, "/", val_expr);
  }
 
private:
  std::string func_name_;
  std::string unit_;
  Expr expr_;
};
 
class IntervalExpr : public ColumnExpression {
public:
  explicit IntervalExpr(std::string interval) : interval_(std::move(interval)) {}
 
  std::string to_sql() const override { return "INTERVAL '" + interval_ + "'"; }
 
  std::vector<std::string> bind_params() const override { return {}; }
 
  std::string column_name() const override { return "INTERVAL"; }
 
  std::string table_name() const override { return ""; }
 
private:
  std::string interval_;
};
 
template <SqlExpr DateExpr, SqlExpr IntervalExpr>
class DateArithmeticExpr : public ColumnExpression {
public:
  DateArithmeticExpr(DateExpr date_expr, std::string op, IntervalExpr interval_expr)
      : date_expr_(std::move(date_expr)), op_(std::move(op)),
        interval_expr_(std::move(interval_expr)) {}
 
  std::string to_sql() const override {
    return "(" + date_expr_.to_sql() + " " + op_ + " " + interval_expr_.to_sql() + ")";
  }
 
  std::vector<std::string> bind_params() const override {
    auto date_params = date_expr_.bind_params();
    auto interval_params = interval_expr_.bind_params();
    date_params.insert(date_params.end(), interval_params.begin(), interval_params.end());
    return date_params;
  }
 
  std::string column_name() const override {
    std::string date_name = "expr";
    if constexpr (std::is_base_of_v<ColumnExpression, DateExpr>) {
      date_name = date_expr_.column_name();
    }
    return "(" + date_name + "_" + op_ + "_INTERVAL)";
  }
 
  std::string table_name() const override {
    if constexpr (std::is_base_of_v<ColumnExpression, DateExpr>) {
      return date_expr_.table_name();
    }
    return "";
  }
 
private:
  DateExpr date_expr_;
  std::string op_;
  IntervalExpr interval_expr_;
};
 
class CurrentDateTimeExpr : public ColumnExpression {
public:
  explicit CurrentDateTimeExpr(std::string func_name) : func_name_(std::move(func_name)) {}
 
  std::string to_sql() const override { return func_name_; }
 
  std::vector<std::string> bind_params() const override { return {}; }
 
  std::string column_name() const override { return func_name_; }
 
  std::string table_name() const override { return ""; }
 
  // Comparison operators with date columns
  template <typename T>
    requires date_checking::DateTimeColumn<T>
  auto operator>(const T& column) const {
    return BinaryCondition<CurrentDateTimeExpr, decltype(to_expr(column))>(*this, ">",
                                                                           to_expr(column));
  }
 
  template <typename T>
    requires date_checking::DateTimeColumn<T>
  auto operator<(const T& column) const {
    return BinaryCondition<CurrentDateTimeExpr, decltype(to_expr(column))>(*this, "<",
                                                                           to_expr(column));
  }
 
  template <typename T>
    requires date_checking::DateTimeColumn<T>
  auto operator>=(const T& column) const {
    return BinaryCondition<CurrentDateTimeExpr, decltype(to_expr(column))>(*this,
                                                                           ">=", to_expr(column));
  }
 
  template <typename T>
    requires date_checking::DateTimeColumn<T>
  auto operator<=(const T& column) const {
    return BinaryCondition<CurrentDateTimeExpr, decltype(to_expr(column))>(*this,
                                                                           "<=", to_expr(column));
  }
 
  template <typename T>
    requires date_checking::DateTimeColumn<T>
  auto operator==(const T& column) const {
    return BinaryCondition<CurrentDateTimeExpr, decltype(to_expr(column))>(*this, "=",
                                                                           to_expr(column));
  }
 
  template <typename T>
    requires date_checking::DateTimeColumn<T>
  auto operator!=(const T& column) const {
    return BinaryCondition<CurrentDateTimeExpr, decltype(to_expr(column))>(*this,
                                                                           "!=", to_expr(column));
  }
 
  // Comparison operators with other date expressions
  template <SqlExpr Expr>
  auto operator>(Expr expr) const {
    return BinaryCondition<CurrentDateTimeExpr, Expr>(*this, ">", std::move(expr));
  }
 
  template <SqlExpr Expr>
  auto operator<(Expr expr) const {
    return BinaryCondition<CurrentDateTimeExpr, Expr>(*this, "<", std::move(expr));
  }
 
  template <SqlExpr Expr>
  auto operator>=(Expr expr) const {
    return BinaryCondition<CurrentDateTimeExpr, Expr>(*this, ">=", std::move(expr));
  }
 
  template <SqlExpr Expr>
  auto operator<=(Expr expr) const {
    return BinaryCondition<CurrentDateTimeExpr, Expr>(*this, "<=", std::move(expr));
  }
 
  template <SqlExpr Expr>
  auto operator==(Expr expr) const {
    return BinaryCondition<CurrentDateTimeExpr, Expr>(*this, "=", std::move(expr));
  }
 
  template <SqlExpr Expr>
  auto operator!=(Expr expr) const {
    return BinaryCondition<CurrentDateTimeExpr, Expr>(*this, "!=", std::move(expr));
  }
 
private:
  std::string func_name_;
};
 
template <SqlExpr Expr1, SqlExpr Expr2>
auto date_diff(std::string_view unit, Expr1 date1, Expr2 date2) {
  return BinaryDateFunctionExpr<Expr1, Expr2>("DATE_DIFF", std::string(unit), std::move(date1),
                                              std::move(date2));
}
 
// Overload for column types with type checking
template <typename T1, typename T2>
  requires date_checking::DateTimeColumn<T1> && date_checking::DateTimeColumn<T2>
auto date_diff(std::string_view unit, const T1& col1, const T2& col2) {
  return date_diff(unit, to_expr(col1), to_expr(col2));
}
 
// Overload for column and expression
template <typename T, SqlExpr Expr>
  requires date_checking::DateTimeColumn<T>
auto date_diff(std::string_view unit, const T& column, Expr expr) {
  return date_diff(unit, to_expr(column), std::move(expr));
}
 
// Overload for expression and column
template <SqlExpr Expr, typename T>
  requires date_checking::DateTimeColumn<T>
auto date_diff(std::string_view unit, Expr expr, const T& column) {
  return date_diff(unit, std::move(expr), to_expr(column));
}
 
template <SqlExpr DateExpr>
auto date_add(DateExpr date_expr, IntervalExpr interval_expr) {
  return DateArithmeticExpr<DateExpr, IntervalExpr>(std::move(date_expr), "+",
                                                    std::move(interval_expr));
}
 
// Overload for column types with type checking
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto date_add(const T& column, IntervalExpr interval_expr) {
  return date_add(to_expr(column), std::move(interval_expr));
}
 
template <SqlExpr DateExpr>
auto date_sub(DateExpr date_expr, IntervalExpr interval_expr) {
  return DateArithmeticExpr<DateExpr, IntervalExpr>(std::move(date_expr), "-",
                                                    std::move(interval_expr));
}
 
// Overload for column types with type checking
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto date_sub(const T& column, IntervalExpr interval_expr) {
  return date_sub(to_expr(column), std::move(interval_expr));
}
 
template <SqlExpr Expr>
auto extract(std::string_view unit, Expr expr) {
  return UnaryDateFunctionExpr<Expr>("EXTRACT", std::string(unit), std::move(expr));
}
 
// Overload for column types with type checking
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto extract(std::string_view unit, const T& column) {
  return extract(unit, to_expr(column));
}
 
template <SqlExpr Expr>
auto date_trunc(std::string_view unit, Expr expr) {
  return UnaryDateFunctionExpr<Expr>("DATE_TRUNC", std::string(unit), std::move(expr));
}
 
// Overload for column types with type checking
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto date_trunc(std::string_view unit, const T& column) {
  return date_trunc(unit, to_expr(column));
}
 
inline auto interval(std::string_view interval_str) {
  return IntervalExpr(std::string(interval_str));
}
 
inline auto current_date() {
  return CurrentDateTimeExpr("CURRENT_DATE");
}
 
inline auto current_time() {
  return CurrentDateTimeExpr("CURRENT_TIME");
}
 
inline auto current_timestamp() {
  return CurrentDateTimeExpr("CURRENT_TIMESTAMP");
}
 
inline auto now() {
  return CurrentDateTimeExpr("NOW()");
}
 
// Helper functions for common date operations
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto age_in_years(const T& birth_date_column) {
  return date_diff("year", birth_date_column, current_date());
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto age_in_years(Expr expr) {
  return date_diff("year", std::move(expr), current_date());
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto days_since(const T& date_column) {
  return date_diff("day", date_column, current_date());
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto days_since(Expr expr) {
  return date_diff("day", std::move(expr), current_date());
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto days_until(const T& date_column) {
  return date_diff("day", current_date(), date_column);
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto days_until(Expr expr) {
  return date_diff("day", current_date(), std::move(expr));
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto start_of_year(const T& date_column) {
  return date_trunc("year", date_column);
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto start_of_year(Expr expr) {
  return date_trunc("year", std::move(expr));
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto start_of_month(const T& date_column) {
  return date_trunc("month", date_column);
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto start_of_month(Expr expr) {
  return date_trunc("month", std::move(expr));
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto start_of_day(const T& date_column) {
  return date_trunc("day", date_column);
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto start_of_day(Expr expr) {
  return date_trunc("day", std::move(expr));
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto year(const T& date_column) {
  return extract("year", date_column);
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto year(Expr expr) {
  return extract("year", std::move(expr));
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto month(const T& date_column) {
  return extract("month", date_column);
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto month(Expr expr) {
  return extract("month", std::move(expr));
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto day(const T& date_column) {
  return extract("day", date_column);
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto day(Expr expr) {
  return extract("day", std::move(expr));
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto day_of_week(const T& date_column) {
  return extract("dow", date_column);
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto day_of_week(Expr expr) {
  return extract("dow", std::move(expr));
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto day_of_year(const T& date_column) {
  return extract("doy", date_column);
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto day_of_year(Expr expr) {
  return extract("doy", std::move(expr));
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto hour(const T& date_column) {
  return extract("hour", date_column);
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto hour(Expr expr) {
  return extract("hour", std::move(expr));
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto minute(const T& date_column) {
  return extract("minute", date_column);
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto minute(Expr expr) {
  return extract("minute", std::move(expr));
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto second(const T& date_column) {
  return extract("second", date_column);
}
 
// Overload for any date expression
template <SqlExpr Expr>
auto second(Expr expr) {
  return extract("second", std::move(expr));
}
 
// Global operator overloads for date arithmetic with intervals
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto operator+(const T& date_column, const IntervalExpr& interval_expr) {
  return DateArithmeticExpr<decltype(to_expr(date_column)), IntervalExpr>(to_expr(date_column), "+",
                                                                          interval_expr);
}
 
template <SqlExpr DateExpr>
auto operator+(DateExpr date_expr, const IntervalExpr& interval_expr) {
  return DateArithmeticExpr<DateExpr, IntervalExpr>(std::move(date_expr), "+", interval_expr);
}
 
template <typename T>
  requires date_checking::DateTimeColumn<T>
auto operator-(const T& date_column, const IntervalExpr& interval_expr) {
  return DateArithmeticExpr<decltype(to_expr(date_column)), IntervalExpr>(to_expr(date_column), "-",
                                                                          interval_expr);
}
 
template <SqlExpr DateExpr>
auto operator-(DateExpr date_expr, const IntervalExpr& interval_expr) {
  return DateArithmeticExpr<DateExpr, IntervalExpr>(std::move(date_expr), "-", interval_expr);
}
 
template <SqlExpr DateExpr, SqlExpr IntervalExpr1>
auto operator+(const DateArithmeticExpr<DateExpr, IntervalExpr1>& date_expr,
               const IntervalExpr& interval_expr) {
  return DateArithmeticExpr<DateArithmeticExpr<DateExpr, IntervalExpr1>, IntervalExpr>(
      date_expr, "+", interval_expr);
}
 
template <SqlExpr DateExpr, SqlExpr IntervalExpr1>
auto operator-(const DateArithmeticExpr<DateExpr, IntervalExpr1>& date_expr,
               const IntervalExpr& interval_expr) {
  return DateArithmeticExpr<DateArithmeticExpr<DateExpr, IntervalExpr1>, IntervalExpr>(
      date_expr, "-", interval_expr);
}
 
template <SqlExpr Expr>
auto abs(Expr expr) {
  return UnaryDateFunctionExpr<Expr>("ABS", "", std::move(expr));
}
 
// Arithmetic operators for UnaryDateFunctionExpr types
 
template <SqlExpr Expr1, SqlExpr Expr2>
auto operator-(const UnaryDateFunctionExpr<Expr1>& left,
               const UnaryDateFunctionExpr<Expr2>& right) {
  return ArithmeticExpr<UnaryDateFunctionExpr<Expr1>, UnaryDateFunctionExpr<Expr2>>(left, "-",
                                                                                    right);
}
 
template <SqlExpr Expr1, SqlExpr Expr2>
auto operator+(const UnaryDateFunctionExpr<Expr1>& left,
               const UnaryDateFunctionExpr<Expr2>& right) {
  return ArithmeticExpr<UnaryDateFunctionExpr<Expr1>, UnaryDateFunctionExpr<Expr2>>(left, "+",
                                                                                    right);
}
 
}  // namespace relx::query