query.hpp

#pragma once
 
#include <algorithm>
#include <cstddef>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
 
#include "query/SelectSpec.hpp"
 
namespace orm
{
class DatabaseCore;
template <typename SchemaType>
class Database;
template <typename T>
class Query
{
public:
    Query() = default;

    auto where(const query::Predicate& predicate) -> Query<T>&
    {
        data.predicate = predicate;
 
        return *this;
    }

    auto andWhere(const query::Predicate& predicate) -> Query<T>&
    {
        data.predicate = data.predicate.has_value() ? data.predicate.value() && predicate : predicate;
 
        return *this;
    }

    auto orWhere(const query::Predicate& predicate) -> Query<T>&
    {
        data.predicate = data.predicate.has_value() ? data.predicate.value() || predicate : predicate;
 
        return *this;
    }

    template <typename... Orders>
    auto orderBy(Orders... orders) -> Query<T>&
    {
        data.orderBy = {std::move(orders)...};
 
        return *this;
    }

    template <typename... Columns>
    auto groupBy(Columns... columns) -> Query<T>&
    {
        data.groupBy = {std::move(columns)...};
 
        return *this;
    }

    auto having(const query::AggregatePredicate& predicate) -> Query<T>&
    {
        data.having = predicate;
 
        return *this;
    }

    auto andHaving(const query::AggregatePredicate& predicate) -> Query<T>&
    {
        data.having = data.having.has_value() ? data.having.value() && predicate : predicate;
 
        return *this;
    }

    auto orHaving(const query::AggregatePredicate& predicate) -> Query<T>&
    {
        data.having = data.having.has_value() ? data.having.value() || predicate : predicate;
 
        return *this;
    }

    inline auto distinct() -> Query<T>&
    {
        data.isDistinct = true;
 
        return *this;
    }

    inline auto offset(std::size_t offset) -> Query<T>&
    {
        data.offset = offset;
 
        return *this;
    }

    inline auto limit(std::size_t limit) -> Query<T>&
    {
        data.limit = limit;
 
        return *this;
    }

    inline auto disableJoining() -> Query<T>&
    {
        data.shouldJoin = false;
 
        return *this;
    }

    auto include(std::string relation) -> Query<T>&
    {
        if (relation.empty())
        {
            throw std::invalid_argument{"Included relation name must not be empty"};
        }
 
        if (std::ranges::find(data.includes, relation) == data.includes.end())
        {
            data.includes.push_back(std::move(relation));
        }
 
        return *this;
    }
 
private:
    template <typename>
    friend class orm::Database;
    friend class orm::DatabaseCore;

    [[nodiscard]] inline auto getData() const -> const query::SelectSpec&
    {
        return data;
    }
 
    query::SelectSpec data; 
};
} // namespace orm