query_builder.hpp

// Copyright 2016 MongoDB Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#pragma once

#include <mangrove/config/prelude.hpp>

#include <chrono>
#include <cstddef>
#include <stdexcept>
#include <tuple>
#include <type_traits>

#include <bsoncxx/builder/core.hpp>
#include <bsoncxx/view_or_value.hpp>

#include <mangrove/expression_syntax.hpp>
#include <mangrove/nvp.hpp>
#include <mangrove/util.hpp>

namespace mangrove {
MANGROVE_INLINE_NAMESPACE_BEGIN

template <typename T>
auto is_bson_appendable_impl(int)
    -> decltype(std::declval<bsoncxx::builder::core>().append(std::declval<T>()), std::true_type{});

template <typename T>
std::false_type is_bson_appendable_impl(...);

template <typename T>
using is_bson_appendable = decltype(is_bson_appendable_impl<T>(0));

template <typename T>
constexpr bool is_bson_appendable_v = is_bson_appendable<T>::value;

// Specialization for appendable types.
template <typename T>
std::enable_if_t<is_bson_appendable_v<T>> append_value_to_bson(T value,
                                                               bsoncxx::builder::core &builder) {
    builder.append(value);
}

// Specialization for non-iterable, non-expression types that must be serialized.
template <typename T>
std::enable_if_t<!is_bson_appendable_v<T> && !is_iterable_not_string_v<T> &&
                 details::isnt_expression_v<T>>
append_value_to_bson(const T &value, bsoncxx::builder::core &builder) {
    auto serialized_value = boson::to_document<T>(value);
    builder.append(bsoncxx::types::b_document{serialized_value});
}

// Specialization for iterable types that must be serialized.
template <typename Iterable>
std::enable_if_t<is_iterable_not_string_v<Iterable>> append_value_to_bson(
    const Iterable &arr, bsoncxx::builder::core &builder) {
    builder.open_array();
    for (const auto &x : arr) {
        append_value_to_bson(x, builder);
    }
    builder.close_array();
}

// Specialization for expression types that must be serialized.
template <typename Expression>
std::enable_if_t<!details::isnt_expression_v<Expression>> append_value_to_bson(
    const Expression &expr, bsoncxx::builder::core &builder) {
    builder.open_document();
    expr.append_to_bson(builder);
    builder.close_document();
}

// std::chrono::time_point must be explicitly serialized into b_date
template <typename Clock, typename Duration>
void append_value_to_bson(const std::chrono::time_point<Clock, Duration> &tp,
                          bsoncxx::builder::core &builder) {
    builder.append(bsoncxx::types::b_date(tp));
}

template <typename NvpT>
class sort_expr {
   public:
    using field_type = NvpT;
    constexpr sort_expr(const NvpT &nvp, bool ascending) : _nvp(nvp), _ascending(ascending) {
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false) const {
        if (wrap) {
            builder.open_document();
        }

        std::string s;
        builder.key_view(_nvp.append_name(s));
        builder.append(_ascending ? 1 : -1);

        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return builder.extract_document();
    }

   private:
    const NvpT _nvp;
    const bool _ascending;
};

template <typename NvpT, typename U>
class comparison_expr {
   public:
    using field_type = NvpT;
    constexpr comparison_expr(const NvpT &nvp, const U &field, const char *op)
        : _nvp(nvp), _field(field), _operator(op) {
    }

    constexpr comparison_expr(const comparison_expr &expr, const char *op)
        : _nvp(expr._nvp), _field(expr._field), _operator(op) {
    }

    std::string &append_name(std::string &s) const {
        return _nvp.append_name(s);
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false,
                        bool omit_name = false) const {
        if (wrap) {
            builder.open_document();
        }
        if (!omit_name && !is_free_nvp_v<field_type>) {
            std::string s;
            builder.key_view(_nvp.append_name(s));
            builder.open_document();
        }

        builder.key_view(_operator);
        append_value_to_bson(_field, builder);

        if (!omit_name && !is_free_nvp_v<field_type>) {
            builder.close_document();
        }
        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return builder.extract_document();
    }

   private:
    const NvpT _nvp;
    const U &_field;
    const char *_operator;
};

template <typename NvpT, typename U>
class comparison_value_expr : public comparison_expr<NvpT, U> {
   public:
    constexpr comparison_value_expr(NvpT nvp, const U &value, const char *op)
        : comparison_expr<NvpT, U>(nvp, _value, op), _value(value) {
    }

   private:
    const U _value;
};

template <typename NvpT>
class mod_expr {
   public:
    using field_type = NvpT;
    constexpr mod_expr(NvpT nvp, const int &divisor, const int &remainder)
        : _nvp(nvp), _divisor(divisor), _remainder(remainder) {
    }

    std::string &append_name(std::string &s) const {
        return _nvp.append_name(s);
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false,
                        bool omit_name = false) const {
        if (wrap) {
            builder.open_document();
        }
        if (!omit_name && !is_free_nvp_v<field_type>) {
            std::string s;
            builder.key_view(_nvp.append_name(s));
            builder.open_document();
        }
        builder.key_view("$mod");
        builder.open_array();
        builder.append(_divisor);
        builder.append(_remainder);
        builder.close_array();
        if (!omit_name && !is_free_nvp_v<field_type>) {
            builder.close_document();
        }
        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return builder.extract_document();
    }

   private:
    const NvpT _nvp;
    const int &_divisor;
    const int &_remainder;
};

class text_search_expr {
   public:
    text_search_expr(const char *search,
                     bsoncxx::stdx::optional<const char *> language = bsoncxx::stdx::nullopt,
                     bsoncxx::stdx::optional<bool> case_sensitive = bsoncxx::stdx::nullopt,
                     bsoncxx::stdx::optional<bool> diacritic_sensitive = bsoncxx::stdx::nullopt)
        : _search(search),
          _language(language),
          _case_sensitive(case_sensitive),
          _diacritic_sensitive(diacritic_sensitive) {
    }

    text_search_expr &language() {
        _language = bsoncxx::stdx::nullopt;
        return *this;
    }

    text_search_expr &language(const char *lang) {
        _language = lang;
        return *this;
    }

    text_search_expr &case_sensitive() {
        _case_sensitive = bsoncxx::stdx::nullopt;
        return *this;
    }

    text_search_expr &case_sensitive(bool case_sensitive) {
        _case_sensitive = case_sensitive;
        return *this;
    }

    text_search_expr &diacritic_sensitive() {
        _diacritic_sensitive = bsoncxx::stdx::nullopt;
        return *this;
    }

    text_search_expr &diacritic_sensitive(bool diacritic_sensitive) {
        _diacritic_sensitive = diacritic_sensitive;
        return *this;
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false) const {
        if (wrap) {
            builder.open_document();
        }
        builder.key_view("$text");
        builder.open_document();
        builder.key_view("$search");
        builder.append(_search);
        if (_language) {
            builder.key_view("$language");
            builder.append(_language.value());
        }
        // hese values are false by default, so one can save bandwidth space ommitting them unless
        // they're set to true.
        if (_case_sensitive) {
            builder.key_view("$caseSensitive");
            builder.append(_case_sensitive.value());
        }
        if (_diacritic_sensitive) {
            builder.key_view("$diacriticSensitive");
            builder.append(_diacritic_sensitive.value());
        }
        builder.close_document();
        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return builder.extract_document();
    }

   private:
    const char *_search;
    mongocxx::stdx::optional<const char *> _language;
    bsoncxx::stdx::optional<bool> _case_sensitive;
    bsoncxx::stdx::optional<bool> _diacritic_sensitive;
};

template <typename Expr>
class not_expr {
   public:
    using field_type = typename Expr::field_type;

    constexpr not_expr(const Expr &expr) : _expr(expr) {
    }

    std::string &append_name(std::string &s) const {
        return _expr.append_name(s);
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false,
                        bool omit_name = false) const {
        if (wrap) {
            builder.open_document();
        }
        if (!omit_name && !is_free_nvp_v<field_type>) {
            std::string s;
            builder.key_view(_expr.append_name(s));
            builder.open_document();
        }

        builder.key_view("$not");
        // Append contained expression in a document, without its name.
        _expr.append_to_bson(builder, true, true);

        if (!omit_name && !is_free_nvp_v<field_type>) {
            builder.close_document();
        }
        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return builder.extract_document();
    }

   private:
    const Expr _expr;
};

template <expression_category list_type, typename... Args>
class expression_list {
   public:
    expression_list(const Args &... args) : storage(std::make_tuple(args...)) {
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false) const {
        tuple_for_each(storage, [&](const auto &v) { v.append_to_bson(builder, wrap); });
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return builder.extract_document();
    }

    std::tuple<Args...> storage;
};

template <typename Expr1, typename Expr2>
class boolean_expr {
   public:
    constexpr boolean_expr(const Expr1 &lhs, const Expr2 &rhs, const char *op)
        : _lhs(lhs), _rhs(rhs), _op(op) {
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false) const {
        if (wrap) {
            builder.open_document();
        }

        builder.key_view(_op);
        builder.open_array();

        // append left hand side
        builder.open_document();
        _lhs.append_to_bson(builder, wrap);
        builder.close_document();

        // append right hand side
        builder.open_document();
        _rhs.append_to_bson(builder, wrap);
        builder.close_document();

        builder.close_array();

        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return builder.extract_document();
    }

    const Expr1 _lhs;
    const Expr2 _rhs;
    const char *_op;
};

template <typename List>
class boolean_list_expr {
   public:
    constexpr boolean_list_expr(const List args, const char *op) : _args(args), _op(op) {
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false) const {
        if (wrap) {
            builder.open_document();
        }
        builder.key_view(_op);
        builder.open_array();
        _args.append_to_bson(builder, true);
        builder.close_array();
        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return builder.extract_document();
    }

    const List _args;
    const char *_op;
};

template <typename Expr>
class isolated_expr {
   public:
    constexpr isolated_expr(const Expr &expr) : _expr(expr) {
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false) const {
        if (wrap) {
            builder.open_document();
        }

        _expr.append_to_bson(builder, false);
        builder.key_view("$isolated");
        builder.append(1);

        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return {builder.extract_document()};
    }

   private:
    const Expr _expr;
};

template <typename NvpT, typename U>
class update_expr {
   public:
    using field_type = NvpT;
    constexpr update_expr(const NvpT &nvp, const U &val, const char *op)
        : _nvp(nvp), _val(val), _op(op) {
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false) const {
        if (wrap) {
            builder.open_document();
        }
        builder.key_view(_op);
        builder.open_document();
        std::string s;
        builder.key_view(_nvp.append_name(s));
        append_value_to_bson(_val, builder);
        builder.close_document();
        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return {builder.extract_document()};
    }

   private:
    const NvpT _nvp;
    const U &_val;
    const char *_op;
};

template <typename NvpT, typename U>
class update_value_expr : public update_expr<NvpT, U> {
   public:
    constexpr update_value_expr(NvpT nvp, U value, const char *op)
        : update_expr<NvpT, U>(nvp, _val, op), _val(value) {
    }

   private:
    const U _val;
};

template <typename NvpT>
class unset_expr {
   public:
    using field_type = NvpT;
    constexpr unset_expr(const NvpT &nvp) : _nvp(nvp) {
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false) const {
        if (wrap) {
            builder.open_document();
        }
        builder.key_view("$unset");
        builder.open_document();
        std::string s;
        builder.key_view(_nvp.append_name(s));
        builder.append("");
        builder.close_document();
        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return {builder.extract_document()};
    }

   private:
    const NvpT _nvp;
};

template <typename NvpT>
class current_date_expr {
   public:
    using field_type = NvpT;
    constexpr current_date_expr(const NvpT &nvp, bool is_date) : _nvp(nvp), _is_date(is_date) {
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false) const {
        if (wrap) {
            builder.open_document();
        }
        builder.key_view("$currentDate");
        builder.open_document();
        std::string s;
        builder.key_view(_nvp.append_name(s));

        // type specification
        builder.open_document();
        builder.key_view("$type");
        builder.append(_is_date ? "date" : "timestamp");
        builder.close_document();

        builder.close_document();
        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return {builder.extract_document()};
    }

   private:
    const NvpT _nvp;
    const bool _is_date;
};

template <typename NvpT, typename U>
class add_to_set_update_expr {
   public:
    using field_type = NvpT;
    constexpr add_to_set_update_expr(const NvpT &nvp, const U &val, bool each)
        : _nvp(nvp), _val(val), _each(each) {
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false) const {
        if (wrap) {
            builder.open_document();
        }
        builder.key_view("$addToSet");
        builder.open_document();
        std::string s;
        builder.key_view(_nvp.append_name(s));

        // wrap value in $each: {} if necessary.
        if (_each) {
            builder.open_document();
            builder.key_view("$each");
        }
        append_value_to_bson(_val, builder);
        if (_each) {
            builder.close_document();
        }

        builder.close_document();
        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return {builder.extract_document()};
    }

   private:
    const NvpT _nvp;
    const U &_val;
    bool _each;
};

template <typename NvpT, typename U, typename Sort>
class push_update_expr {
   public:
    using field_type = NvpT;
    constexpr push_update_expr(
        const NvpT &nvp, const U &val, bool each,
        bsoncxx::stdx::optional<std::int32_t> slice = bsoncxx::stdx::nullopt,
        const bsoncxx::stdx::optional<Sort> &sort = bsoncxx::stdx::nullopt,
        bsoncxx::stdx::optional<std::uint32_t> position = bsoncxx::stdx::nullopt)
        : _nvp(nvp), _val(val), _each(each), _slice(slice), _sort(sort), _position(position) {
    }

    /* Functions that set new values for modifers. These create new copies of the expression,
     * primarily because $sort can take different types of parameters. */

    constexpr push_update_expr<NvpT, U, Sort> slice(std::int32_t slice) {
        return {_nvp, _val, _each, slice, _sort, _position};
    }

    constexpr push_update_expr<NvpT, U, Sort> slice() {
        return {_nvp, _val, _each, bsoncxx::stdx::nullopt, _sort, _position};
    }

    template <typename OtherNvpT>
    constexpr push_update_expr<NvpT, U, sort_expr<OtherNvpT>> sort(
        const sort_expr<OtherNvpT> &sort) {
        return {_nvp, _val, _each, _slice, sort, _position};
    }

    constexpr push_update_expr<NvpT, U, int> sort(int sort) {
        return {_nvp, _val, _each, _slice, sort, _position};
    }

    constexpr push_update_expr<NvpT, U, Sort> sort() {
        return {_nvp, _val, _each, _slice, bsoncxx::stdx::nullopt, _position};
    }

    constexpr push_update_expr<NvpT, U, Sort> position(std::uint32_t position) {
        return {_nvp, _val, _each, _slice, _sort, position};
    }

    constexpr push_update_expr<NvpT, U, Sort> position() {
        return {_nvp, _val, _each, _slice, _sort, bsoncxx::stdx::nullopt};
    }

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false) const {
        if (wrap) {
            builder.open_document();
        }
        builder.key_view("$push");
        builder.open_document();
        std::string s;
        builder.key_view(_nvp.append_name(s));

        // wrap value in "$each: {}" if necessary.
        if (_each) {
            builder.open_document();
            builder.key_view("$each");
        }
        append_value_to_bson(_val, builder);
        if (_each) {
            if (_slice) {
                builder.key_view("$slice");
                builder.append(_slice.value());
            }
            if (_sort) {
                builder.key_view("$sort");
                append_value_to_bson(_sort.value(), builder);
            }
            if (_position) {
                builder.key_view("$position");
                builder.append(static_cast<std::int64_t>(_position.value()));
            }
            builder.close_document();
        }

        builder.close_document();
        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return {builder.extract_document()};
    }

   private:
    const NvpT _nvp;
    const U &_val;
    const bool _each;
    const bsoncxx::stdx::optional<std::int32_t> _slice;
    const bsoncxx::stdx::optional<Sort> _sort;
    const bsoncxx::stdx::optional<std::uint32_t> _position;
};

template <typename NvpT, typename Integer>
class bit_update_expr {
   public:
    using field_type = NvpT;
    constexpr bit_update_expr(const NvpT &nvp, Integer mask, const char *op)
        : _nvp(nvp), _mask(mask), _operation(op){};

    void append_to_bson(bsoncxx::builder::core &builder, bool wrap = false) const {
        if (wrap) {
            builder.open_document();
        }
        builder.key_view("$bit");
        builder.open_document();
        std::string s;
        builder.key_view(_nvp.append_name(s));

        // bit operation
        builder.open_document();
        builder.key_view(_operation);
        builder.append(_mask);
        builder.close_document();

        builder.close_document();
        if (wrap) {
            builder.close_document();
        }
    }

    operator bsoncxx::document::view_or_value() const {
        auto builder = bsoncxx::builder::core(false);
        append_to_bson(builder);
        return {builder.extract_document()};
    }

   private:
    const NvpT _nvp;
    const Integer _mask;
    const char *_operation;
};

/* Query comparison operators */

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>>
constexpr comparison_expr<NvpT, typename NvpT::no_opt_type> eq(
    const NvpT &lhs, const typename NvpT::no_opt_type &rhs) {
    return {lhs, rhs, "$eq"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>>
constexpr comparison_expr<NvpT, typename NvpT::no_opt_type> operator==(
    const NvpT &lhs, const typename NvpT::no_opt_type &rhs) {
    return eq(lhs, rhs);
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>>
constexpr comparison_expr<NvpT, typename NvpT::no_opt_type> gt(
    const NvpT &lhs, const typename NvpT::no_opt_type &rhs) {
    return {lhs, rhs, "$gt"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>>
constexpr comparison_expr<NvpT, typename NvpT::no_opt_type> operator>(
    const NvpT &lhs, const typename NvpT::no_opt_type &rhs) {
    return gt(lhs, rhs);
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>>
constexpr comparison_expr<NvpT, typename NvpT::no_opt_type> gte(
    const NvpT &lhs, const typename NvpT::no_opt_type &rhs) {
    return {lhs, rhs, "$gte"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>>
constexpr comparison_expr<NvpT, typename NvpT::no_opt_type> operator>=(
    const NvpT &lhs, const typename NvpT::no_opt_type &rhs) {
    return gte(lhs, rhs);
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>>
constexpr comparison_expr<NvpT, typename NvpT::no_opt_type> lt(
    const NvpT &lhs, const typename NvpT::no_opt_type &rhs) {
    return {lhs, rhs, "$lt"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>>
constexpr comparison_expr<NvpT, typename NvpT::no_opt_type> operator<(
    const NvpT &lhs, const typename NvpT::no_opt_type &rhs) {
    return lt(lhs, rhs);
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>>
constexpr comparison_expr<NvpT, typename NvpT::no_opt_type> lte(
    const NvpT &lhs, const typename NvpT::no_opt_type &rhs) {
    return {lhs, rhs, "$lte"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>>
constexpr comparison_expr<NvpT, typename NvpT::no_opt_type> operator<=(
    const NvpT &lhs, const typename NvpT::no_opt_type &rhs) {
    return lte(lhs, rhs);
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>>
constexpr comparison_expr<NvpT, typename NvpT::no_opt_type> ne(
    const NvpT &lhs, const typename NvpT::no_opt_type &rhs) {
    return {lhs, rhs, "$ne"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>>
constexpr comparison_expr<NvpT, typename NvpT::no_opt_type> operator!=(
    const NvpT &lhs, const typename NvpT::no_opt_type &rhs) {
    return ne(lhs, rhs);
}

// TODO replace is_query_expression with is_unary_expression or something.
template <typename Expr, typename = std::enable_if_t<details::is_query_expression_v<Expr>>>
constexpr not_expr<Expr> operator!(const Expr &expr) {
    return {expr};
}

// Specialization of the ! operator for regexes, since the $regex operator cannot appear inside
// a $not operator.
// Instead, create an expression of the form {field: {$not: /regex/}}
template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>>
constexpr comparison_expr<NvpT, bsoncxx::types::b_regex> operator!(
    const comparison_value_expr<NvpT, bsoncxx::types::b_regex> &regex_expr) {
    return {regex_expr, "$not"};
}

template <typename Expr, expression_category list_type, typename... Args, size_t... idxs>
constexpr expression_list<list_type, Expr, Args...> append_impl(
    expression_list<list_type, Args...> list, Expr expr, std::index_sequence<idxs...>) {
    return {expr, std::get<idxs>(list.storage)...};
}

template <typename Expr, expression_category list_type,
          typename = std::enable_if_t<details::is_expression_type<list_type, Expr>::value>,
          typename... Args>
constexpr expression_list<list_type, Expr, Args...> operator,(
    expression_list<list_type, Args...> &&list, Expr &&expr) {
    return append_impl(list, expr, std::index_sequence_for<Args...>());
}

template <typename Expr1, typename Expr2,
          typename = std::enable_if_t<!details::isnt_expression_v<Expr1> &&
                                      (details::expression_type<Expr1>::value ==
                                       details::expression_type<Expr2>::value)>>
constexpr expression_list<details::expression_type<Expr1>::value, Expr1, Expr2> operator,(
    Expr1 &&expr1, Expr2 &&expr2) {
    return {expr1, expr2};
}

template <typename Expr1, typename Expr2,
          typename = std::enable_if_t<details::is_query_expression_v<Expr1> &&
                                      details::is_query_expression_v<Expr2>>>
constexpr boolean_expr<Expr1, Expr2> operator&&(const Expr1 &lhs, const Expr2 &rhs) {
    return {lhs, rhs, "$and"};
}

template <typename Expr1, typename Expr2,
          typename = std::enable_if_t<details::is_query_expression_v<Expr1> &&
                                      details::is_query_expression_v<Expr2>>>
constexpr boolean_expr<Expr1, Expr2> operator||(const Expr1 &lhs, const Expr2 &rhs) {
    return {lhs, rhs, "$or"};
}

// TODO I'd like list ops for "and" and "or" as well, but these are reserved keywords.
// Perhaps use list_and, list_or, list_nor instead?
// Currently chaining &&'s or ||'s provides the same results as a boolean operation on a list,
// and
// not much different in terms of performance.

template <typename... Args>
constexpr boolean_list_expr<expression_list<expression_category::query, Args...>> nor(
    const expression_list<expression_category::query, Args...> &list) {
    return {list, "$nor"};
}

template <typename... QueryExpressions,
          typename = typename all_true<details::is_query_expression_v<QueryExpressions>...>::type>
constexpr boolean_list_expr<expression_list<expression_category::query, QueryExpressions...>> nor(
    QueryExpressions... args) {
    return {{args...}, "$nor"};
}

inline text_search_expr text(
    const char *search, bsoncxx::stdx::optional<const char *> language = bsoncxx::stdx::nullopt,
    bsoncxx::stdx::optional<bool> case_sensitive = bsoncxx::stdx::nullopt,
    bsoncxx::stdx::optional<bool> diacritic_sensitive = bsoncxx::stdx::nullopt) {
    return {search, language, case_sensitive, diacritic_sensitive};
}

template <typename Expr, typename = std::enable_if_t<details::is_query_expression_v<Expr>>>
constexpr isolated_expr<Expr> isolated(const Expr &expr) {
    return {expr};
}

/* Arithmetic update operators */

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>,
          typename = std::enable_if_t<std::is_arithmetic<typename NvpT::no_opt_type>::value>>
constexpr update_expr<NvpT, typename NvpT::no_opt_type> operator+=(
    const NvpT &nvp, const typename NvpT::no_opt_type &val) {
    return {nvp, val, "$inc"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>,
          typename = std::enable_if_t<std::is_arithmetic<typename NvpT::no_opt_type>::value>>
constexpr update_value_expr<NvpT, typename NvpT::no_opt_type> operator-=(
    const NvpT &nvp, const typename NvpT::no_opt_type &val) {
    return {nvp, -val, "$inc"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>,
          typename = std::enable_if_t<std::is_arithmetic<typename NvpT::no_opt_type>::value>>
constexpr update_value_expr<NvpT, typename NvpT::no_opt_type> operator++(const NvpT &nvp) {
    return {nvp, 1, "$inc"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>,
          typename = std::enable_if_t<std::is_arithmetic<typename NvpT::no_opt_type>::value>>
constexpr update_value_expr<NvpT, typename NvpT::no_opt_type> operator++(const NvpT &nvp, int) {
    return {nvp, 1, "$inc"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>,
          typename = std::enable_if_t<std::is_arithmetic<typename NvpT::no_opt_type>::value>>
constexpr update_value_expr<NvpT, typename NvpT::no_opt_type> operator--(const NvpT &nvp) {
    return {nvp, -1, "$inc"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>,
          typename = std::enable_if_t<std::is_arithmetic<typename NvpT::no_opt_type>::value>>
constexpr update_value_expr<NvpT, typename NvpT::no_opt_type> operator--(const NvpT &nvp, int) {
    return {nvp, -1, "$inc"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>,
          typename = std::enable_if_t<std::is_arithmetic<typename NvpT::no_opt_type>::value>>
constexpr update_expr<NvpT, typename NvpT::no_opt_type> operator*=(
    const NvpT &nvp, const typename NvpT::no_opt_type &val) {
    return {nvp, val, "$mul"};
}

/* Bitwise update operators */

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>,
          typename = std::enable_if_t<std::is_integral<typename NvpT::no_opt_type>::value>>
constexpr bit_update_expr<NvpT, typename NvpT::no_opt_type> operator&=(
    const NvpT &nvp, const typename NvpT::no_opt_type &mask) {
    return {nvp, mask, "and"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>,
          typename = std::enable_if_t<std::is_integral<typename NvpT::no_opt_type>::value>>
constexpr bit_update_expr<NvpT, typename NvpT::no_opt_type> operator|=(
    const NvpT &nvp, const typename NvpT::no_opt_type &mask) {
    return {nvp, mask, "or"};
}

template <typename NvpT, typename = std::enable_if_t<is_nvp_v<NvpT>>,
          typename = std::enable_if_t<std::is_integral<typename NvpT::no_opt_type>::value>>
constexpr bit_update_expr<NvpT, typename NvpT::no_opt_type> operator^=(
    const NvpT &nvp, const typename NvpT::no_opt_type &mask) {
    return {nvp, mask, "xor"};
}

MANGROVE_INLINE_NAMESPACE_END
}  // namespace mangrove

#include <mangrove/config/postlude.hpp>