condition.hpp

Go to the documentation of this file.

#pragma once
 
#include "column_expression.hpp"
#include "core.hpp"
#include "schema_adapter.hpp"
 
#include <memory>
#include <sstream>
#include <string>
#include <vector>
 
namespace relx::query {
 
template <SqlExpr Left, SqlExpr Right>
class BinaryCondition : public SqlExpression {
public:
  BinaryCondition(Left left, std::string op, Right right)
      : left_(std::move(left)), op_(std::move(op)), right_(std::move(right)) {}
 
  std::string to_sql() const override {
    std::stringstream ss;
    ss << "(" << left_.to_sql() << " " << op_ << " " << right_.to_sql() << ")";
    return ss.str();
  }
 
  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;
  }
 
private:
  Left left_;
  std::string op_;
  Right right_;
};
 
template <SqlExpr Left, SqlExpr Right>
auto operator==(Left left, Right right) {
  return BinaryCondition<Left, Right>(std::move(left), "=", std::move(right));
}
 
template <SqlExpr Left, SqlExpr Right>
auto operator!=(Left left, Right right) {
  return BinaryCondition<Left, Right>(std::move(left), "!=", std::move(right));
}
 
template <SqlExpr Left, SqlExpr Right>
auto operator>(Left left, Right right) {
  return BinaryCondition<Left, Right>(std::move(left), ">", std::move(right));
}
 
template <SqlExpr Left, SqlExpr Right>
auto operator<(Left left, Right right) {
  return BinaryCondition<Left, Right>(std::move(left), "<", std::move(right));
}
 
template <SqlExpr Left, SqlExpr Right>
auto operator>=(Left left, Right right) {
  return BinaryCondition<Left, Right>(std::move(left), ">=", std::move(right));
}
 
template <SqlExpr Left, SqlExpr Right>
auto operator<=(Left left, Right right) {
  return BinaryCondition<Left, Right>(std::move(left), "<=", std::move(right));
}
 
template <SqlExpr Left, SqlExpr Right>
auto operator&&(Left left, Right right) {
  return BinaryCondition<Left, Right>(std::move(left), "AND", std::move(right));
}
 
template <SqlExpr Left, SqlExpr Right>
auto operator||(Left left, Right right) {
  return BinaryCondition<Left, Right>(std::move(left), "OR", std::move(right));
}
 
template <SqlExpr Expr, std::ranges::range Range>
  requires std::convertible_to<std::ranges::range_value_t<Range>, std::string>
class TypedInCondition : public SqlExpression {
public:
  TypedInCondition(Expr expr, Range values) : expr_(std::move(expr)), values_(std::move(values)) {}
 
  std::string to_sql() const override {
    std::stringstream ss;
    ss << expr_.to_sql() << " IN (";
    bool first = true;
    for (const auto& _ : values_) {
      if (!first) {
        ss << ", ";
      }
      ss << "?";
      first = false;
    }
    ss << ")";
    return ss.str();
  }
 
  std::vector<std::string> bind_params() const override {
    auto params = expr_.bind_params();
    for (const auto& value : values_) {
      params.push_back(value);
    }
    return params;
  }
 
private:
  Expr expr_;
  Range values_;
};
 
template <typename TableT, schema::fixed_string Name, typename T, typename... Modifiers,
          std::ranges::range Range>
  requires std::convertible_to<std::ranges::range_value_t<Range>, std::string>
auto in(const schema::column<TableT, Name, T, Modifiers...>& col, Range values) {
  using ValueType = std::ranges::range_value_t<Range>;
 
  // Type check for IN operations - ensure the values are compatible with the column type
  if constexpr (std::same_as<T, std::string> || std::same_as<T, std::string_view>) {
    static_assert(std::convertible_to<ValueType, std::string>,
                  "IN operation with string column requires string-convertible values");
  } else if constexpr (std::is_arithmetic_v<T>) {
    static_assert(std::convertible_to<ValueType, std::string>,
                  "IN operation values must be convertible to string for parameter binding");
  }
 
  auto col_expr = to_expr(col);
  return TypedInCondition<decltype(col_expr), Range>(std::move(col_expr), std::move(values));
}
 
template <SqlExpr Expr, std::ranges::range Range>
  requires std::convertible_to<std::ranges::range_value_t<Range>, std::string>
class InCondition : public SqlExpression {
public:
  InCondition(Expr expr, Range values) : expr_(std::move(expr)), values_(std::move(values)) {}
 
  std::string to_sql() const override {
    std::stringstream ss;
    ss << expr_.to_sql() << " IN (";
    bool first = true;
    for (const auto& _ : values_) {
      if (!first) {
        ss << ", ";
      }
      ss << "?";
      first = false;
    }
    ss << ")";
    return ss.str();
  }
 
  std::vector<std::string> bind_params() const override {
    auto params = expr_.bind_params();
    for (const auto& value : values_) {
      params.push_back(value);
    }
    return params;
  }
 
private:
  Expr expr_;
  Range values_;
};
 
template <SqlExpr Expr, std::ranges::range Range>
  requires std::convertible_to<std::ranges::range_value_t<Range>, std::string>
auto in(Expr expr, Range values) {
  return InCondition<Expr, Range>(std::move(expr), std::move(values));
}
 
template <SqlExpr Expr>
class LikeCondition : public SqlExpression {
public:
  LikeCondition(Expr expr, std::string pattern)
      : expr_(std::move(expr)), pattern_(std::move(pattern)) {}
 
  std::string to_sql() const override { return expr_.to_sql() + " LIKE ?"; }
 
  std::vector<std::string> bind_params() const override {
    auto params = expr_.bind_params();
    params.push_back(pattern_);
    return params;
  }
 
private:
  Expr expr_;
  std::string pattern_;
};
 
template <SqlExpr Expr>
auto like(Expr expr, std::string pattern) {
  return LikeCondition<Expr>(std::move(expr), std::move(pattern));
}
 
template <SqlExpr Expr>
class BetweenCondition : public SqlExpression {
public:
  BetweenCondition(Expr expr, std::string lower, std::string upper)
      : expr_(std::move(expr)), lower_(std::move(lower)), upper_(std::move(upper)) {}
 
  std::string to_sql() const override { return expr_.to_sql() + " BETWEEN ? AND ?"; }
 
  std::vector<std::string> bind_params() const override {
    auto params = expr_.bind_params();
    params.push_back(lower_);
    params.push_back(upper_);
    return params;
  }
 
private:
  Expr expr_;
  std::string lower_;
  std::string upper_;
};
 
template <SqlExpr Expr>
auto between(Expr expr, std::string lower, std::string upper) {
  return BetweenCondition<Expr>(std::move(expr), std::move(lower), std::move(upper));
}
 
template <SqlExpr Expr>
class IsNullCondition : public SqlExpression {
public:
  explicit IsNullCondition(Expr expr) : expr_(std::move(expr)) {}
 
  std::string to_sql() const override { return expr_.to_sql() + " IS NULL"; }
 
  std::vector<std::string> bind_params() const override { return expr_.bind_params(); }
 
private:
  Expr expr_;
};
 
template <SqlExpr Expr>
auto is_null(Expr expr) {
  return IsNullCondition<Expr>(std::move(expr));
}
 
template <SqlExpr Expr>
class IsNotNullCondition : public SqlExpression {
public:
  explicit IsNotNullCondition(Expr expr) : expr_(std::move(expr)) {}
 
  std::string to_sql() const override { return expr_.to_sql() + " IS NOT NULL"; }
 
  std::vector<std::string> bind_params() const override { return expr_.bind_params(); }
 
private:
  Expr expr_;
};
 
template <SqlExpr Expr>
auto is_not_null(Expr expr) {
  return IsNotNullCondition<Expr>(std::move(expr));
}
 
template <SqlExpr Expr>
class NotCondition : public SqlExpression {
public:
  explicit NotCondition(Expr expr) : expr_(std::move(expr)) {}
 
  std::string to_sql() const override { return "(NOT " + expr_.to_sql() + ")"; }
 
  std::vector<std::string> bind_params() const override { return expr_.bind_params(); }
 
private:
  Expr expr_;
};
 
template <SqlExpr Expr>
auto operator!(Expr expr) {
  return NotCondition<Expr>(std::move(expr));
}
 
}  // namespace relx::query