delete.hpp

Go to the documentation of this file.

#pragma once
 
#include "column_expression.hpp"
#include "condition.hpp"
#include "core.hpp"
#include "operators.hpp"
#include "value.hpp"
 
#include <memory>
#include <optional>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
namespace relx::query {
 
template <TableType Table, typename Where = std::nullopt_t>
class DeleteQuery {
public:
  using table_type = Table;
  using where_type = Where;
 
  explicit DeleteQuery(Table table, Where where = std::nullopt)
      : table_(std::move(table)), where_(std::move(where)) {}
 
  std::string to_sql() const {
    std::stringstream ss;
    ss << "DELETE FROM " << table_.table_name;
 
    // Add WHERE clause
    if constexpr (!std::is_same_v<Where, std::nullopt_t>) {
      if (where_.has_value()) {
        ss << " WHERE " << where_.value().to_sql();
      }
    }
 
    return ss.str();
  }
 
  std::vector<std::string> bind_params() const {
    std::vector<std::string> params;
 
    // Collect parameters from WHERE clause
    if constexpr (!std::is_same_v<Where, std::nullopt_t>) {
      if (where_.has_value()) {
        auto where_params = where_.value().bind_params();
        params.insert(params.end(), where_params.begin(), where_params.end());
      }
    }
 
    return params;
  }
 
  template <ConditionExpr Condition>
  auto where(const Condition& cond) const {
    return DeleteQuery<Table, std::optional<Condition>>(table_, std::optional<Condition>(cond));
  }
 
  template <ColumnType Col, std::ranges::range Range>
    requires std::convertible_to<std::ranges::range_value_t<Range>, std::string>
  auto where_in(const Col& column, const Range& values) const {
    auto col_expr = column_ref(column);
    auto in_condition = in(col_expr, values);
    return where(in_condition);
  }
 
private:
  Table table_;
  Where where_;
};
 
template <TableType Table>
auto delete_from(const Table& table) {
  return DeleteQuery<Table>(table);
}
 
}  // namespace relx::query