transaction.h

#pragma once
 
#include <ozo/core/options.h>
#include <ozo/detail/begin_statement_builder.h>
#include <ozo/transaction_status.h>
 
namespace ozo {
 
template <typename Connection, typename Options>
class transaction {
public:
    static_assert(ozo::Connection<Connection>, "Connection should model Connection concept");
 
    using handle_type = Connection; 
    using lowest_layer_type = unwrap_type<handle_type>; 
    using native_handle_type = typename lowest_layer_type::native_handle_type; 
    using oid_map_type = typename lowest_layer_type::oid_map_type; 
    using error_context_type = typename lowest_layer_type::error_context_type; 
    using executor_type = typename lowest_layer_type::executor_type; 
    using options_type = std::decay_t<Options>; 
 
    transaction() = default;
 
    transaction(Connection&& connection, Options options) noexcept(
        std::is_nothrow_move_constructible_v<Connection>
        && std::is_nothrow_move_constructible_v<Options>)
    : impl_(std::move(connection)), options_(std::move(options)) {}
 
    native_handle_type native_handle() const noexcept {
        return lowest_layer().native_handle();
    }
 
    const oid_map_type& oid_map() const noexcept { return lowest_layer().oid_map();}
 
    template <typename Key, typename Value>
    void update_statistics(const Key& key, Value&& v) noexcept {
        lowest_layer().update_statistics(key, std::forward<Value>(v));
    }
    decltype(auto) statistics() const noexcept {
        return lowest_layer().statistics();
    }
 
    const error_context_type& get_error_context() const noexcept {
        return lowest_layer().get_error_context();
    }
    void set_error_context(error_context_type v = error_context_type{}) {
        lowest_layer().set_error_context(std::move(v));
    }
 
    executor_type get_executor() const noexcept {
        return lowest_layer().get_executor();
    }
 
    friend handle_type release_connection(transaction&& x) noexcept {
        return std::move(x.impl_);
    }
 
    template <typename WaitHandler>
    void async_wait_write(WaitHandler&& handler) {
        lowest_layer().async_wait_write(std::forward<WaitHandler>(handler));
    }
 
    template <typename WaitHandler>
    void async_wait_read(WaitHandler&& handler) {
        lowest_layer().async_wait_read(std::forward<WaitHandler>(handler));
    }
 
    error_code close() noexcept { return lowest_layer().close();}
 
    void cancel() noexcept { lowest_layer().cancel();}
 
    bool is_bad() const noexcept { return lowest_layer().is_bad();}
 
    operator bool () const noexcept { return !(is_null() || is_bad());}
 
    bool is_open() const noexcept { return !is_null() && lowest_layer().is_open();}
 
    constexpr const options_type& options() const noexcept { return options_;}
 
    lowest_layer_type& lowest_layer() noexcept { return ozo::unwrap(impl_);}
 
    const lowest_layer_type& lowest_layer() const noexcept {return ozo::unwrap(impl_);}
 
private:
    bool is_null() const noexcept { return ozo::is_null(impl_); }
 
    friend struct is_null_impl<transaction>;
    handle_type impl_;
    options_type options_;
};
 
template <typename ...Ts>
struct is_connection<transaction<Ts...>> : std::true_type {};
 
namespace impl {
// [[DEPRECATED]] for backward compatibility only
template <typename ...Ts>
using transaction = ozo::transaction<Ts...>;
} // namespace impl
 
namespace detail {
struct initiate_async_start_transaction {
    template <typename Handler, typename ...Args>
    constexpr void operator()(Handler&& h, Args&& ...args) const;
};
} // namespace detail
 
#ifdef OZO_DOCUMENTATION
 
template <typename ConnectionProvider, typename TimeConstraint, typename CompletionToken>
decltype(auto) begin (ConnectionProvider&& provider, TimeConstraint time_constraint, CompletionToken&& token);
 
template <typename ConnectionProvider, typename CompletionToken>
decltype(auto) begin (ConnectionProvider&& provider, CompletionToken&& token);
 
#endif
template <typename Initiator, typename Options = decltype(make_options())>
struct begin_op : base_async_operation <begin_op<Initiator, Options>, Initiator> {
    using base = typename begin_op::base;
    Options options_;
 
    constexpr explicit begin_op(Initiator initiator = {}, Options options = {}) : base(initiator), options_(options) {}
 
    template <typename T, typename TimeConstraint, typename CompletionToken>
    auto operator() (T&& provider, TimeConstraint t, CompletionToken&& token) const {
        static_assert(ConnectionProvider<T>, "provider should be a ConnectionProvider");
        static_assert(ozo::TimeConstraint<TimeConstraint>, "should model TimeConstraint concept");
        using namespace ozo::literals;
        return async_initiate<CompletionToken, handler_signature<transaction<connection_type<T>, Options>>>(
            get_operation_initiator(*this), token,
            std::forward<T>(provider), options_, detail::begin_statement_builder::build(options_), t);
    }
 
    template <typename T, typename CompletionToken>
    auto operator() (T&& provider, CompletionToken&& token) const {
        return (*this)(
            std::forward<T>(provider),
            none,
            std::forward<CompletionToken>(token)
        );
    }
 
    template <typename OtherOptions>
    constexpr auto with_transaction_options(const OtherOptions& options) const {
        return begin_op<Initiator, OtherOptions>{get_operation_initiator(*this), options};
    }
 
    template <typename OtherInitiator>
    constexpr auto rebind_initiator(const OtherInitiator& other) const {
        return begin_op<OtherInitiator, Options>{other, options_};
    }
};
 
inline constexpr begin_op<detail::initiate_async_start_transaction> begin;
 
 
namespace detail {
struct initiate_async_end_transaction {
    template <typename Handler, typename ...Args>
    constexpr void operator()(Handler&& h, Args&& ...args) const;
};
} // namespace detail
 
#ifdef OZO_DOCUMENTATION
 
template <typename T, typename Options, typename TimeConstraint, typename CompletionToken>
decltype(auto) commit (transaction<T, Options>&& transaction, TimeConstraint t, CompletionToken&& token);
 
template <typename ConnectionProvider, typename CompletionToken>
decltype(auto) commit (ConnectionProvider&& provider, CompletionToken&& token);
 
#endif
struct commit_op {
    template <typename T, typename Options, typename TimeConstraint, typename CompletionToken>
    auto operator() (transaction<T, Options>&& transaction, TimeConstraint t, CompletionToken&& token) const {
        static_assert(ozo::TimeConstraint<TimeConstraint>, "should model TimeConstraint concept");
        using namespace ozo::literals;
        return async_initiate<CompletionToken, handler_signature<typename ozo::transaction<T, Options>::handle_type>>(
            detail::initiate_async_end_transaction{}, token,
            std::move(transaction), "COMMIT"_SQL, t);
    }
 
    template <typename... Ts, typename CompletionToken>
    auto operator() (transaction<Ts...>&& transaction, CompletionToken&& token) const {
        return (*this)(
            std::move(transaction),
            none,
            std::forward<CompletionToken>(token)
        );
    }
};
 
inline constexpr commit_op commit;
 
 
#ifdef OZO_DOCUMENTATION
 
template <typename T, typename Options, typename TimeConstraint, typename CompletionToken>
decltype(auto) rollback (transaction<T, Options>&& transaction, TimeConstraint t, CompletionToken&& token);
 
template <typename ConnectionProvider, typename CompletionToken>
decltype(auto) rollback (ConnectionProvider&& provider, CompletionToken&& token);
 
#endif
struct rollback_op {
    template <typename T, typename Options, typename TimeConstraint, typename CompletionToken>
    auto operator() (transaction<T, Options>&& transaction, TimeConstraint t, CompletionToken&& token) const {
        static_assert(ozo::TimeConstraint<TimeConstraint>, "should model TimeConstraint concept");
        using namespace ozo::literals;
        return async_initiate<CompletionToken, handler_signature<typename ozo::transaction<T, Options>::handle_type>>(
            detail::initiate_async_end_transaction{}, token,
            std::move(transaction), "ROLLBACK"_SQL, t);
    }
 
    template <typename... Ts, typename CompletionToken>
    auto operator() (transaction<Ts...>&& transaction, CompletionToken&& token) const {
        return (*this)(
            std::move(transaction),
            none,
            std::forward<CompletionToken>(token)
        );
    }
};
 
inline constexpr rollback_op rollback;
 
 
template<typename... Ts>
constexpr auto get_transaction_isolation_level(const transaction<Ts...>& transaction) {
    return get_option(transaction.options(), transaction_options::isolation_level, none);
}
 
template<typename... Ts>
constexpr auto get_transaction_mode(const transaction<Ts...>& transaction) {
    return get_option(transaction.options(), transaction_options::mode, none);
}
 
template<typename... Ts>
constexpr auto get_transaction_deferrability(const transaction<Ts...>& transaction) {
    return get_option(transaction.options(), transaction_options::deferrability, none);
}
 
} // namespace ozo
 
#include <ozo/impl/transaction.h>