result_mapper.hpp

#pragma once
 
#include <iterator>
#include <memory>
#include <optional>
#include <type_traits>
#include <utility>
 
#include <boost/pfr/core.hpp>
 
#include <userver/storages/clickhouse/impl/block_wrapper_fwd.hpp>
#include <userver/storages/clickhouse/impl/iterators_helper.hpp>
#include <userver/storages/clickhouse/io/columns/column_wrapper.hpp>
#include <userver/storages/clickhouse/io/io_fwd.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace storages::clickhouse::io {
 
class IteratorsTester;
 
template <typename MappedType>
class ColumnsMapper final {
public:
    explicit ColumnsMapper(clickhouse::impl::BlockWrapper& block)
        : block_{block}
    {}
 
    template <typename Field, size_t Index>
    void operator()(Field& field, std::integral_constant<size_t, Index> i) {
        using ColumnType = std::tuple_element_t<Index, MappedType>;
        static_assert(std::is_same_v<Field, typename ColumnType::container_type>);
 
        auto column = ColumnType{io::columns::GetWrappedColumn(block_, i)};
        field.reserve(column.Size());
        for (auto& it : column) {
            field.push_back(std::move(it));
        }
    }
 
private:
    clickhouse::impl::BlockWrapper& block_;
};
 
template <typename Row>
class RowsMapper final {
public:
    using MappedType = typename CppToClickhouse<Row>::mapped_type;
    explicit RowsMapper(clickhouse::impl::BlockWrapperPtr&& block)
        : block_{block.release()}
    {
        IteratorsHelperT::Init(begin_iterators_, end_iterators_, *block_);
    }
    ~RowsMapper() = default;
 
    using IteratorsTupleT = clickhouse::impl::IteratorsTupleT<MappedType>;
 
    class Iterator final {
    public:
        using iterator_category = std::forward_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using value_type = Row;
        using reference = value_type&;
        using pointer = value_type*;
 
        Iterator() = default;
        Iterator(IteratorsTupleT iterators);
 
        Iterator operator++(int);
        Iterator& operator++();
        reference operator*() const;
        pointer operator->() const;
 
        bool operator==(const Iterator& other) const;
        bool operator!=(const Iterator& other) const;
 
        friend class IteratorsTester;
 
    private:
        Row& UpdateValue() const;
 
        class FieldMapper final {
        public:
            FieldMapper(const IteratorsTupleT& iterators)
                : iterators_{iterators}
            {}
 
            template <typename Field, size_t Index>
            void operator()(Field& field, [[maybe_unused]] std::integral_constant<size_t, Index> i) const {
                if constexpr (kCanMoveFromIterators) {
                    field = std::move(*std::get<Index>(iterators_));
                } else {
                    field = *std::get<Index>(iterators_);
                }
            }
 
        private:
            const IteratorsTupleT& iterators_;
        };
 
        IteratorsTupleT iterators_;
        mutable std::optional<Row> current_value_ = std::nullopt;
    };
 
    Iterator begin() const { return Iterator{begin_iterators_}; }
    Iterator end() const { return Iterator{end_iterators_}; }
 
    friend class IteratorsTester;
 
private:
    template <typename TypesTuple>
    struct IteratorValuesAreNoexceptMovable;
 
    template <typename... Ts>
    struct IteratorValuesAreNoexceptMovable<std::tuple<Ts...>>
        : std::conjunction<std::is_nothrow_move_constructible<typename Ts::iterator::value_type>...> {};
 
    static constexpr auto kCanMoveFromIterators = IteratorValuesAreNoexceptMovable<MappedType>::value;
 
    using IteratorsHelperT = clickhouse::impl::IteratorsHelper<MappedType>;
 
    clickhouse::impl::BlockWrapperPtr block_;
    IteratorsTupleT begin_iterators_{};
    IteratorsTupleT end_iterators_{};
};
 
template <typename Row>
RowsMapper<Row>::Iterator::Iterator(IteratorsTupleT iterators)
    : iterators_{std::move(iterators)}
{}
 
template <typename Row>
typename RowsMapper<Row>::Iterator RowsMapper<Row>::Iterator::operator++(int) {
    Iterator old{};
    old.iterators_ = IteratorsHelperT::PostfixIncrement(iterators_);
    old.current_value_ = std::move_if_noexcept(current_value_);
    current_value_.reset();
 
    return old;
}
 
template <typename Row>
typename RowsMapper<Row>::Iterator& RowsMapper<Row>::Iterator::operator++() {
    IteratorsHelperT::PrefixIncrement(iterators_);
    current_value_.reset();
 
    return *this;
}
 
template <typename Row>
typename RowsMapper<Row>::Iterator::reference RowsMapper<Row>::Iterator::operator*() const {
    return UpdateValue();
}
 
template <typename Row>
typename RowsMapper<Row>::Iterator::pointer RowsMapper<Row>::Iterator::operator->() const {
    return &UpdateValue();
}
 
template <typename Row>
Row& RowsMapper<Row>::Iterator::UpdateValue() const {
    if (!current_value_.has_value()) {
        Row result{};
        boost::pfr::for_each_field(result, FieldMapper{iterators_});
        current_value_.emplace(std::move(result));
    }
 
    return *current_value_;
}
 
template <typename Row>
bool RowsMapper<Row>::Iterator::operator==(const Iterator& other) const {
    return iterators_ == other.iterators_;
}
 
template <typename Row>
bool RowsMapper<Row>::Iterator::operator!=(const Iterator& other) const {
    return !((*this) == other);
}
 
}  // namespace storages::clickhouse::io
 
USERVER_NAMESPACE_END