array_column.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/storages/clickhouse/io/columns/array_column.hpp
/// @brief Array column support
/// @ingroup userver_clickhouse_types
 
#include <userver/utils/assert.hpp>
 
#include <userver/storages/clickhouse/io/columns/column_includes.hpp>
#include <userver/storages/clickhouse/io/columns/common_columns.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace storages::clickhouse::io::columns {
 
struct ArrayColumnMeta final {
    ColumnRef data;
    ColumnRef offsets;
};
 
ColumnRef ConvertMetaToColumn(ArrayColumnMeta&& meta);
ColumnRef ExtractArrayItem(const ColumnRef& column, std::size_t ind);
 
/// @brief Represents ClickHouse Array(T) column,
/// where T is a ClickhouseColumn as well
template <typename T>
class ArrayColumn final : public ClickhouseColumn<ArrayColumn<T>> {
public:
    using cpp_type = std::vector<typename T::cpp_type>;
    using container_type = std::vector<cpp_type>;
 
    ArrayColumn(ColumnRef column);
 
    class ArrayDataHolder final {
    public:
        ArrayDataHolder() = default;
        ArrayDataHolder(typename ColumnIterator<ArrayColumn<T>>::IteratorPosition iter_position, ColumnRef&& column);
 
        ArrayDataHolder operator++(int);
        ArrayDataHolder& operator++();
        cpp_type& UpdateValue();
 
        bool operator==(const ArrayDataHolder& other) const;
 
    private:
        ColumnRef inner_{};
        std::size_t ind_{0};
        std::optional<cpp_type> current_value_ = std::nullopt;
    };
    using iterator_data = ArrayDataHolder;
 
    static ColumnRef Serialize(const container_type& from);
    static cpp_type RetrieveElement(const ColumnRef& ref, std::size_t ind);
};
 
template <typename T>
ArrayColumn<T>::ArrayDataHolder::ArrayDataHolder(
    typename ColumnIterator<ArrayColumn<T>>::IteratorPosition iter_position,
    ColumnRef&& column
)
    : inner_{std::move(column)},
      ind_(iter_position == decltype(iter_position)::kEnd ? GetColumnSize(inner_) : 0)
{}
 
template <typename T>
typename ArrayColumn<T>::ArrayDataHolder ArrayColumn<T>::ArrayDataHolder::operator++(int) {
    ArrayDataHolder old{};
    old.inner_ = inner_;
    old.ind_ = ind_++;
    old.current_value_ = std::move_if_noexcept(current_value_);
    current_value_.reset();
 
    return old;
}
 
template <typename T>
typename ArrayColumn<T>::ArrayDataHolder& ArrayColumn<T>::ArrayDataHolder::operator++() {
    ++ind_;
    current_value_.reset();
 
    return *this;
}
 
template <typename T>
typename ArrayColumn<T>::cpp_type& ArrayColumn<T>::ArrayDataHolder::UpdateValue() {
    UASSERT(ind_ < GetColumnSize(inner_));
    if (!current_value_.has_value()) {
        cpp_type item = RetrieveElement(inner_, ind_);
        current_value_.emplace(std::move(item));
    }
 
    return *current_value_;
}
 
template <typename T>
bool ArrayColumn<T>::ArrayDataHolder::operator==(const ArrayDataHolder& other) const {
    return inner_.get() == other.inner_.get() && ind_ == other.ind_;
}
 
template <typename T>
ArrayColumn<T>::ArrayColumn(ColumnRef column)
    : ClickhouseColumn<ArrayColumn>{std::move(column)}
{}
 
template <typename T>
ColumnRef ArrayColumn<T>::Serialize(const container_type& from) {
    uint64_t cumulative_offset = 0;
    std::vector<uint64_t> offsets;
    offsets.reserve(from.size());
 
    for (const auto& value : from) {
        cumulative_offset += value.size();
        offsets.push_back(cumulative_offset);
    }
    typename T::container_type values;
    values.reserve(cumulative_offset);
 
    for (const auto& value : from) {
        for (const auto& item : value) {
            values.push_back(item);
        }
    }
 
    ArrayColumnMeta array_meta;
    array_meta.offsets = UInt64Column::Serialize(offsets);
    array_meta.data = T::Serialize(values);
 
    return ConvertMetaToColumn(std::move(array_meta));
}
 
template <typename T>
typename ArrayColumn<T>::cpp_type ArrayColumn<T>::RetrieveElement(const ColumnRef& ref, std::size_t ind) {
    auto array_item = ExtractArrayItem(ref, ind);
    T typed_column(array_item);
 
    cpp_type result;
    result.reserve(GetColumnSize(array_item));
    for (auto it = typed_column.begin(); it != typed_column.end(); ++it) {
        result.push_back(std::move(*it));
    }
    return result;
}
 
}  // namespace storages::clickhouse::io::columns
 
USERVER_NAMESPACE_END