expr.hpp

#pragma once
 
#include <initializer_list>
#include <iron_query/operator_precedence.hpp>
#include <memory>
#include <string>
#include <string_view>
#include <type_traits>
 
namespace iron_query {
 
class VirtualTable;
class Condition;
class Collation;
class SelectItem;
 
namespace impl {
struct Node;
} // namespace impl
 
namespace impl {
 
template <typename T>
inline constexpr bool kIsSqlInteger =
    std::is_integral_v<T> && !std::is_same_v<std::remove_cv_t<T>, bool> &&
    !std::is_same_v<std::remove_cv_t<T>, char> &&
    !std::is_same_v<std::remove_cv_t<T>, signed char> &&
    !std::is_same_v<std::remove_cv_t<T>, unsigned char> &&
    !std::is_same_v<std::remove_cv_t<T>, wchar_t> &&
    !std::is_same_v<std::remove_cv_t<T>, char16_t> &&
    !std::is_same_v<std::remove_cv_t<T>, char32_t>;
 
} // namespace impl
 
class [[nodiscard]] Expr final {
public:
  template <typename T, std::enable_if_t<impl::kIsSqlInteger<T>, int> = 0>
  Expr(T value)
      : Expr(FromInteger(
            static_cast<std::conditional_t<std::is_signed_v<T>, long long,
                                           unsigned long long>>(value))) {}
 
  template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
  Expr(T value) : Expr(FromDouble(static_cast<double>(value))) {}
 
  Expr(bool) = delete;
 
  Expr(char) = delete;
 
  Expr(const char *) = delete;
 
  static Expr
  FromRaw(std::string s,
          OperatorPrecedence precedence = OperatorPrecedence::kSymbol);
 
  static Expr Literal(const std::string &value);
 
  static Expr Ident(const std::string &name);
 
  static Expr Null();
 
  static Expr Bool(bool value);
 
  static Expr Call(const std::string &name, std::initializer_list<Expr> args);
 
  static Expr CallDistinct(const std::string &name,
                           std::initializer_list<Expr> args);
 
  static Expr Coalesce(std::initializer_list<Expr> args);
 
  static Expr NullIf(const Expr &a, const Expr &b);
 
  static Expr Greatest(std::initializer_list<Expr> args);
 
  static Expr Least(std::initializer_list<Expr> args);
 
  static Condition Exists(const VirtualTable &subquery);
 
  static Condition NotExists(const VirtualTable &subquery);
 
  static Expr
  PrefixOp(const std::string &op, const Expr &operand,
           OperatorPrecedence precedence = OperatorPrecedence::kUnaryPlus);
 
  static Expr Count(const Expr &arg);
 
  static Expr CountAll();
 
  static Expr CountDistinct(const Expr &arg);
 
  static Expr Sum(const Expr &arg);
 
  static Expr Avg(const Expr &arg);
 
  static Expr Min(const Expr &arg);
 
  static Expr Max(const Expr &arg);
 
  Expr Dot(const Expr &other) const;
 
  Expr CastRaw(const std::string &type) const;
 
  Expr Collate(const Collation &collation) const;
 
  Expr operator[](const Expr &other) const;
 
  Expr operator^(const Expr &other) const;
 
  Expr
  BinaryOp(const std::string &op, const Expr &other,
           OperatorPrecedence precedence = OperatorPrecedence::kAnyOther) const;
 
  Condition Between(const Expr &a, const Expr &b) const;
 
  Condition NotBetween(const Expr &a, const Expr &b) const;
 
  Condition Like(const Expr &a) const;
 
  Condition NotLike(const Expr &a) const;
 
  Condition ILike(const Expr &a) const;
 
  Condition NotILike(const Expr &a) const;
 
  Condition SimilarTo(const Expr &a) const;
 
  Condition NotSimilarTo(const Expr &a) const;
 
  Condition In(std::initializer_list<Expr> values) const;
 
  Condition In(const VirtualTable &subquery) const;
 
  Condition NotIn(std::initializer_list<Expr> values) const;
 
  Condition NotIn(const VirtualTable &subquery) const;
 
  Condition EqAny(const Expr &array) const;
 
  Condition EqAny(const VirtualTable &subquery) const;
 
  Condition NeAll(const Expr &array) const;
 
  Condition NeAll(const VirtualTable &subquery) const;
 
  Condition IsTrue() const;
 
  Condition IsFalse() const;
 
  Condition IsNull() const;
 
  Condition IsNotNull() const;
 
  Condition IsDistinctFrom(const Expr &other) const;
 
  Condition IsNotDistinctFrom(const Expr &other) const;
 
  Expr operator+(const Expr &other) const;
 
  Expr operator-(const Expr &other) const;
 
  Expr operator*(const Expr &other) const;
 
  Expr operator/(const Expr &other) const;
 
  Expr operator%(const Expr &other) const;
 
  Expr operator-() const;
 
  Expr operator!() const;
 
  Expr Concat(const Expr &other) const;
 
  SelectItem As(std::string_view name) const;
 
  std::string Extract(OperatorPrecedence precedence) const;
 
  std::string ToString() const;
 
private:
  friend class Condition;
  friend Condition operator<(const Expr &a, const Expr &b);
  friend Condition operator<=(const Expr &a, const Expr &b);
  friend Condition operator>(const Expr &a, const Expr &b);
  friend Condition operator>=(const Expr &a, const Expr &b);
  friend Condition operator==(const Expr &a, const Expr &b);
  friend Condition operator!=(const Expr &a, const Expr &b);
 
  Expr(std::string s);
  Expr(std::string expr, OperatorPrecedence precedence);
  explicit Expr(std::shared_ptr<const impl::Node> node);
 
  static Expr FromInteger(long long value);
  static Expr FromInteger(unsigned long long value);
  static Expr FromDouble(double value);
 
  static Condition CompareOp(const Expr &a, const char *op, const Expr &b);
 
  static std::shared_ptr<const impl::Node>
  BuildCallNode(const std::string &name, const char *args_prefix,
                std::initializer_list<Expr> args);
  static std::shared_ptr<const impl::Node>
  BuildInListNode(const Expr &self, const char *connector,
                  std::initializer_list<Expr> values);
 
  std::shared_ptr<const impl::Node> node_;
};
 
Condition operator<(const Expr &a, const Expr &b);
 
Condition operator<=(const Expr &a, const Expr &b);
 
Condition operator>(const Expr &a, const Expr &b);
 
Condition operator>=(const Expr &a, const Expr &b);
 
Condition operator==(const Expr &a, const Expr &b);
 
Condition operator!=(const Expr &a, const Expr &b);
 
} // namespace iron_query