select_expr.hpp

#pragma once
 
#include <initializer_list>
#include <iron_query/condition.hpp>
#include <iron_query/order_by.hpp>
#include <iron_query/select_item.hpp>
#include <iron_query/virtual_table.hpp>
#include <optional>
#include <string>
#include <vector>
 
namespace iron_query {
 
class [[nodiscard]] SelectExpr final : public VirtualTable {
public:
  SelectExpr(const VirtualTable &tbl);
 
  SelectExpr Distinct() &&;
 
  SelectExpr DistinctOn(Expr exp) &&;
 
  SelectExpr DistinctOn(std::initializer_list<Expr> exps) &&;
 
  SelectExpr Select(SelectItem item) &&;
 
  SelectExpr Select(std::initializer_list<SelectItem> items) &&;
 
  SelectExpr Where(Condition exp) &&;
 
  SelectExpr OrderBy(OrderByTerm term) &&;
 
  SelectExpr OrderBy(std::initializer_list<OrderByTerm> terms) &&;
 
  SelectExpr GroupBy(Expr exp) &&;
 
  SelectExpr GroupBy(std::initializer_list<Expr> exps) &&;
 
  SelectExpr Having(Condition exp) &&;
 
  SelectExpr Limit(int limit) &&;
 
  SelectExpr Offset(int offset) &&;
 
  std::string ToString() const override;
 
  std::string ToStringFormatted() const override;
 
private:
  void EnsureValid() const;
 
  bool distinct_{false};
  std::optional<std::vector<Expr>> distinct_on_;
  std::string from_;
  std::optional<std::vector<SelectItem>> select_;
  std::optional<Condition> where_;
  std::optional<std::vector<Expr>> group_by_;
  std::optional<Condition> having_;
  std::optional<std::vector<OrderByTerm>> order_by_;
  std::optional<int> limit_;
  std::optional<int> offset_;
};
 
SelectExpr From(const VirtualTable &tbl);
 
} // namespace iron_query