common.h

Go to the documentation of this file.

#pragma once

 
#include "fwd.h"
 
#include <library/cpp/type_info/type_info.h>
#include <library/cpp/yson/node/node.h>
 
#include <util/generic/guid.h>
#include <util/generic/map.h>
#include <util/generic/maybe.h>
#include <util/generic/ptr.h>
#include <util/generic/vector.h>
 
#include <google/protobuf/message.h>
 
#include <initializer_list>
#include <type_traits>
 
namespace NYT {


#define FLUENT_FIELD(type, name) \
    type name##_; \
    TSelf& name(const type& value) \
    { \
        name##_ = value; \
        return static_cast<TSelf&>(*this); \
    } \
    static_assert(true)
 
#define FLUENT_FIELD_ENCAPSULATED(type, name) \
private: \
    type name##_; \
public: \
    TSelf& name(const type& value) & \
    { \
        name##_ = value; \
        return static_cast<TSelf&>(*this); \
    } \
    TSelf name(const type& value) && \
    { \
        name##_ = value; \
        return static_cast<TSelf&>(*this); \
    } \
    const type& name() const & \
    { \
        return name##_; \
    } \
    type name() && \
    { \
        return name##_; \
    } \
    static_assert(true)
 
#define FLUENT_FIELD_OPTION(type, name) \
    TMaybe<type> name##_; \
    TSelf& name(const type& value) \
    { \
        name##_ = value; \
        return static_cast<TSelf&>(*this); \
    } \
    static_assert(true)
 
#define FLUENT_FIELD_OPTION_ENCAPSULATED(type, name) \
private: \
    TMaybe<type> name##_; \
public: \
    TSelf& name(const type& value) & \
    { \
        name##_ = value; \
        return static_cast<TSelf&>(*this); \
    } \
    TSelf name(const type& value) && \
    { \
        name##_ = value; \
        return static_cast<TSelf&>(*this); \
    } \
    TSelf& Reset##name() & \
    { \
        name##_ = Nothing(); \
        return static_cast<TSelf&>(*this); \
    } \
    TSelf Reset##name() && \
    { \
        name##_ = Nothing(); \
        return static_cast<TSelf&>(*this); \
    } \
    const TMaybe<type>& name() const& \
    { \
        return name##_; \
    } \
    TMaybe<type> name() && \
    { \
        return name##_; \
    } \
    static_assert(true)
 
#define FLUENT_FIELD_DEFAULT(type, name, defaultValue) \
    type name##_ = defaultValue; \
    TSelf& name(const type& value) \
    { \
        name##_ = value; \
        return static_cast<TSelf&>(*this); \
    } \
    static_assert(true)
 
#define FLUENT_FIELD_DEFAULT_ENCAPSULATED(type, name, defaultValue) \
private: \
    type name##_ = defaultValue; \
public: \
    TSelf& name(const type& value) & \
    { \
        name##_ = value; \
        return static_cast<TSelf&>(*this); \
    } \
    TSelf name(const type& value) && \
    { \
        name##_ = value; \
        return static_cast<TSelf&>(*this); \
    } \
    const type& name() const & \
    { \
        return name##_; \
    } \
    type name() && \
    { \
        return name##_; \
    } \
    static_assert(true)
 
#define FLUENT_VECTOR_FIELD(type, name) \
    TVector<type> name##s_; \
    TSelf& Add##name(const type& value) \
    { \
        name##s_.push_back(value); \
        return static_cast<TSelf&>(*this);\
    } \
    TSelf& name##s(TVector<type> values) \
    { \
        name##s_ = std::move(values); \
        return static_cast<TSelf&>(*this);\
    } \
    static_assert(true)
 
#define FLUENT_OPTIONAL_VECTOR_FIELD_ENCAPSULATED(type, name) \
private: \
    TMaybe<TVector<type>> name##s_; \
public: \
    const TMaybe<TVector<type>>& name##s() const & { \
        return name##s_; \
    } \
    TMaybe<TVector<type>>& name##s() & { \
        return name##s_; \
    } \
    TMaybe<TVector<type>> name##s() && { \
        return std::move(name##s_); \
    } \
    TSelf& Add##name(const type& value) & \
    { \
        if (name##s_.Empty()) { \
            name##s_.ConstructInPlace(); \
        } \
        name##s_->push_back(value); \
        return static_cast<TSelf&>(*this);\
    } \
    TSelf Add##name(const type& value) && \
    { \
        if (name##s_.Empty()) { \
            name##s_.ConstructInPlace(); \
        } \
        name##s_->push_back(value); \
        return static_cast<TSelf&&>(*this);\
    } \
    TSelf& name##s(TVector<type> values) & \
    { \
        name##s_ = std::move(values); \
        return static_cast<TSelf&>(*this);\
    } \
    TSelf name##s(TVector<type> values) && \
    { \
        name##s_ = std::move(values); \
        return static_cast<TSelf&&>(*this);\
    } \
    TSelf& name##s(TNothing) & \
    { \
        name##s_ = Nothing(); \
        return static_cast<TSelf&>(*this);\
    } \
    TSelf name##s(TNothing) && \
    { \
        name##s_ = Nothing(); \
        return static_cast<TSelf&&>(*this);\
    } \
    TSelf& Reset##name##s() & \
    { \
        name##s_ = Nothing(); \
        return static_cast<TSelf&>(*this);\
    } \
    TSelf Reset##name##s() && \
    { \
        name##s_ = Nothing(); \
        return static_cast<TSelf&&>(*this);\
    } \
    static_assert(true)
 
#define FLUENT_VECTOR_FIELD_ENCAPSULATED(type, name) \
private: \
    TVector<type> name##s_; \
public: \
    TSelf& Add##name(const type& value) & \
    { \
        name##s_.push_back(value); \
        return static_cast<TSelf&>(*this);\
    } \
    TSelf Add##name(const type& value) && \
    { \
        name##s_.push_back(value); \
        return static_cast<TSelf&>(*this);\
    } \
    TSelf& name##s(TVector<type> value) & \
    { \
        name##s_ = std::move(value); \
        return static_cast<TSelf&>(*this);\
    } \
    TSelf name##s(TVector<type> value) && \
    { \
        name##s_ = std::move(value); \
        return static_cast<TSelf&>(*this);\
    } \
    const TVector<type>& name##s() const & \
    { \
        return name##s_; \
    } \
    TVector<type> name##s() && \
    { \
        return name##s_; \
    } \
    static_assert(true)
 
#define FLUENT_MAP_FIELD(keytype, valuetype, name) \
    TMap<keytype,valuetype> name##_; \
    TSelf& Add##name(const keytype& key, const valuetype& value) \
    { \
        name##_.emplace(key, value); \
        return static_cast<TSelf&>(*this);\
    } \
    static_assert(true)



template <class T, class TDerived>
struct TOneOrMany
{
    using TSelf = std::conditional_t<std::is_void_v<TDerived>, TOneOrMany, TDerived>;

    TOneOrMany() = default;
 
    // Initialize from initializer list.
    template<class U>
    TOneOrMany(std::initializer_list<U> il)
    {
        Parts_.assign(il.begin(), il.end());
    }

    template <class U, class... TArgs>
        requires std::is_convertible_v<U, T>
    TOneOrMany(U&& arg, TArgs&&... args)
    {
        Add(arg, std::forward<TArgs>(args)...);
    }

    TOneOrMany(TVector<T> args)
        : Parts_(std::move(args))
    { }

    bool operator==(const TOneOrMany& rhs) const
    {
        // N.B. We would like to make this method to be `= default`,
        // but this breaks MSVC compiler for the cases when T doesn't
        // support comparison.
        return Parts_ == rhs.Parts_;
    }

    template <class U, class... TArgs>
        requires std::is_convertible_v<U, T>
    TSelf& Add(U&& part, TArgs&&... args) &
    {
        Parts_.push_back(std::forward<U>(part));
        if constexpr (sizeof...(args) > 0) {
            [[maybe_unused]] int dummy[sizeof...(args)] = {(Parts_.push_back(std::forward<TArgs>(args)), 0) ... };
        }
        return static_cast<TSelf&>(*this);
    }
 
    template <class U, class... TArgs>
        requires std::is_convertible_v<U, T>
    TSelf Add(U&& part, TArgs&&... args) &&
    {
        return std::move(Add(std::forward<U>(part), std::forward<TArgs>(args)...));
    }

    TVector<T> Parts_;
};


enum EValueType : int
{
    VT_INT64,

    VT_UINT64,

    VT_DOUBLE,
    VT_BOOLEAN,

    VT_STRING,

    VT_ANY,

    VT_INT8,
    VT_INT16,
    VT_INT32,

    VT_UINT8,
    VT_UINT16,
    VT_UINT32,

    VT_UTF8,

    VT_NULL,
    VT_VOID,

    VT_DATE,
    VT_DATETIME,
    VT_TIMESTAMP,
    VT_INTERVAL,

    VT_FLOAT,
    VT_JSON,
 
    // Date32, number of days shifted from Unix epoch, which is 0 (signed)
    VT_DATE32,
    // Datetime64, number of seconds shifted from Unix epoch, which is 0 (signed)
    VT_DATETIME64,
    // Timestamp64, number of milliseconds shifted from Unix epoch, which is 0 (signed)
    VT_TIMESTAMP64,
    // Interval64, difference between two timestamps64 (signed)
    VT_INTERVAL64,
 
    // Universally unique identifier according to RFC-4122.
    VT_UUID,
 
    VT_TZ_DATE,
    VT_TZ_DATETIME,
    VT_TZ_TIMESTAMP,
    VT_TZ_DATE32,
    VT_TZ_DATETIME64,
    VT_TZ_TIMESTAMP64,
};

enum ESortOrder : int
{
    SO_ASCENDING    /* "ascending" */,
    SO_DESCENDING   /* "descending" */,
};

enum EOptimizeForAttr : i8
{
    OF_SCAN_ATTR    /* "scan" */,

    OF_LOOKUP_ATTR  /* "lookup" */,
};

enum EErasureCodecAttr : i8
{
    EC_NONE_ATTR                /* "none" */,
    EC_REED_SOLOMON_6_3_ATTR    /* "reed_solomon_6_3" */,
    EC_LRC_12_2_2_ATTR          /* "lrc_12_2_2" */,
    EC_ISA_LRC_12_2_2_ATTR      /* "isa_lrc_12_2_2" */,
    EC_ISA_REED_SOLOMON_6_3_ATTR    /* "isa_reed_solomon_6_3" */,
    EC_ISA_REED_SOLOMON_3_3_ATTR    /* "isa_reed_solomon_3_3" */,
};

enum ESchemaModificationAttr : i8
{
    SM_NONE_ATTR                    /* "none" */,
    SM_UNVERSIONED_UPDATE           /* "unversioned_update" */,
};


class TSortColumn
{
public:
    using TSelf = TSortColumn;

    FLUENT_FIELD_ENCAPSULATED(TString, Name);

    FLUENT_FIELD_DEFAULT_ENCAPSULATED(ESortOrder, SortOrder, ESortOrder::SO_ASCENDING);

    TSortColumn(TStringBuf name = {}, ESortOrder sortOrder = ESortOrder::SO_ASCENDING);
    TSortColumn(const TString& name, ESortOrder sortOrder = ESortOrder::SO_ASCENDING);
    TSortColumn(const char* name, ESortOrder sortOrder = ESortOrder::SO_ASCENDING);

    const TSortColumn& EnsureAscending() const;

    TNode ToNode() const;

    bool operator==(const TSortColumn& rhs) const = default;

    TSortColumn& operator=(TStringBuf name);
    TSortColumn& operator=(const TString& name);
    TSortColumn& operator=(const char* name);
 
    bool operator==(const TStringBuf rhsName) const;
    bool operator==(const TString& rhsName) const;
    bool operator==(const char* rhsName) const;
 
    // Intentionally implicit conversions.
    operator TString() const;
    operator TStringBuf() const;
    operator std::string() const;
 
    Y_SAVELOAD_DEFINE(Name_, SortOrder_);
};

class TSortColumns
    : public TOneOrMany<TSortColumn, TSortColumns>
{
public:
    using TOneOrMany<TSortColumn, TSortColumns>::TOneOrMany;

    TSortColumns();

    TSortColumns(const TVector<TString>& names);
    TSortColumns(const TColumnNames& names);
 

    operator TColumnNames() const;

    const TSortColumns& EnsureAscending() const;

    TVector<TString> GetNames() const;
};


NTi::TTypePtr ToTypeV3(EValueType type, bool required);

class TColumnSchema
{
public:
    using TSelf = TColumnSchema;

    TColumnSchema();

    TColumnSchema(const TColumnSchema&) = default;
    TColumnSchema& operator=(const TColumnSchema&) = default;
 
 
    FLUENT_FIELD_ENCAPSULATED(TString, Name);

    TColumnSchema& Type(EValueType type) &;
    TColumnSchema Type(EValueType type) &&;
    EValueType Type() const;

    TColumnSchema& Type(const NTi::TTypePtr& type) &;
    TColumnSchema Type(const NTi::TTypePtr& type) &&;
 
    TColumnSchema& TypeV3(const NTi::TTypePtr& type) &;
    TColumnSchema TypeV3(const NTi::TTypePtr& type) &&;
    NTi::TTypePtr TypeV3() const;

    FLUENT_FIELD_OPTION_ENCAPSULATED(ESortOrder, SortOrder);

    FLUENT_FIELD_OPTION_ENCAPSULATED(TString, Lock);

    FLUENT_FIELD_OPTION_ENCAPSULATED(TString, Expression);

    FLUENT_FIELD_OPTION_ENCAPSULATED(TString, Aggregate);

    FLUENT_FIELD_OPTION_ENCAPSULATED(TString, Group);
 
    // StableName for renamed and deleted columns.
    FLUENT_FIELD_OPTION_ENCAPSULATED(TString, StableName);

    bool Required() const;

    TColumnSchema& Type(EValueType type, bool required) &;
    TColumnSchema Type(EValueType type, bool required) &&;

    const TMaybe<TNode>& RawTypeV3() const;
    TColumnSchema& RawTypeV3(TNode rawTypeV3)&;
    TColumnSchema RawTypeV3(TNode rawTypeV3)&&;
 
 
private:
    friend void Deserialize(TColumnSchema& columnSchema, const TNode& node);
    NTi::TTypePtr TypeV3_;
    TMaybe<TNode> RawTypeV3_;
};

bool operator==(const TColumnSchema& lhs, const TColumnSchema& rhs);

class TDeletedColumnSchema
{
public:
    using TSelf = TDeletedColumnSchema;

    TDeletedColumnSchema() = default;

    TDeletedColumnSchema(const TDeletedColumnSchema&) = default;
    TDeletedColumnSchema& operator=(const TDeletedColumnSchema&) = default;
 
    // StableName for renamed and deleted columns.
    FLUENT_FIELD_OPTION_ENCAPSULATED(TString, StableName);
 
private:
    friend void Deserialize(TDeletedColumnSchema& columnSchema, const TNode& node);
};

bool operator==(const TDeletedColumnSchema& lhs, const TDeletedColumnSchema& rhs);

class TTableSchema
{
public:
    using TSelf = TTableSchema;

    FLUENT_VECTOR_FIELD_ENCAPSULATED(TColumnSchema, Column);

    FLUENT_FIELD_DEFAULT_ENCAPSULATED(bool, Strict, true);

    FLUENT_FIELD_DEFAULT_ENCAPSULATED(bool, UniqueKeys, false);

    FLUENT_VECTOR_FIELD_ENCAPSULATED(TDeletedColumnSchema, DeletedColumn);

    TVector<TColumnSchema>& MutableColumns();

    [[nodiscard]] bool Empty() const;

    TTableSchema& AddColumn(const TString& name, const NTi::TTypePtr& type, ESortOrder sortOrder) &;
    TTableSchema AddColumn(const TString& name, const NTi::TTypePtr& type, ESortOrder sortOrder) &&;

    TTableSchema& AddColumn(const TString& name, const NTi::TTypePtr& type) &;
    TTableSchema AddColumn(const TString& name, const NTi::TTypePtr& type) &&;

    TTableSchema& AddColumn(const TString& name, EValueType type, ESortOrder sortOrder) &;
    TTableSchema AddColumn(const TString& name, EValueType type, ESortOrder sortOrder) &&;

    TTableSchema& AddColumn(const TString& name, EValueType type) &;
    TTableSchema AddColumn(const TString& name, EValueType type) &&;

    TTableSchema& SortBy(const TSortColumns& columns) &;

    TTableSchema SortBy(const TSortColumns& columns) &&;

    [[nodiscard]] TNode ToNode() const;

    static NYT::TTableSchema FromNode(const TNode& node);
 
    friend void Deserialize(TTableSchema& tableSchema, const TNode& node);
};

bool operator==(const TTableSchema& lhs, const TTableSchema& rhs);
 
// Pretty printer for unittests
void PrintTo(const TTableSchema& schema, std::ostream* out);

TTableSchema CreateTableSchema(
    const ::google::protobuf::Descriptor& messageDescriptor,
    const TSortColumns& sortColumns = TSortColumns(),
    bool keepFieldsWithoutExtension = true);

template <class TProtoType, typename = std::enable_if_t<std::is_base_of_v<::google::protobuf::Message, TProtoType>>>
inline TTableSchema CreateTableSchema(
    const TSortColumns& sortColumns = TSortColumns(),
    bool keepFieldsWithoutExtension = true)
{
    static_assert(
        std::is_base_of_v<::google::protobuf::Message, TProtoType>,
        "Template argument must be derived from ::google::protobuf::Message");
 
    return CreateTableSchema(
        *TProtoType::descriptor(),
        sortColumns,
        keepFieldsWithoutExtension);
}

TTableSchema CreateTableSchema(NTi::TTypePtr type);


enum class ERelation
{
    Less            /* "<"  */,

    LessOrEqual     /* "<=" */,

    Greater         /* ">"  */,

    GreaterOrEqual  /* ">=" */,
};

struct TKeyBound
{
    using TSelf = TKeyBound;
 
    explicit TKeyBound(ERelation relation = ERelation::Less, TKey key = TKey{});
 
    FLUENT_FIELD_DEFAULT_ENCAPSULATED(ERelation, Relation, ERelation::Less);
    FLUENT_FIELD_DEFAULT_ENCAPSULATED(TKey, Key, TKey{});
};

bool operator==(const TKeyBound& lhs, const TKeyBound& rhs) noexcept;

struct TReadLimit
{
    using TSelf = TReadLimit;

    FLUENT_FIELD_OPTION(TKeyBound, KeyBound);

    FLUENT_FIELD_OPTION(TKey, Key);

    FLUENT_FIELD_OPTION(i64, RowIndex);

    FLUENT_FIELD_OPTION(i64, Offset);

    FLUENT_FIELD_OPTION(i64, TabletIndex);
};

bool operator==(const TReadLimit& lhs, const TReadLimit& rhs) noexcept;

struct TReadRange
{
    using TSelf = TReadRange;

    FLUENT_FIELD(TReadLimit, LowerLimit);

    FLUENT_FIELD(TReadLimit, UpperLimit);

    FLUENT_FIELD(TReadLimit, Exact);

    static TReadRange FromRowIndices(i64 lowerLimit, i64 upperLimit)
    {
        return TReadRange()
            .LowerLimit(TReadLimit().RowIndex(lowerLimit))
            .UpperLimit(TReadLimit().RowIndex(upperLimit));
    }

    static TReadRange FromKeys(const TKey& lowerKeyInclusive, const TKey& upperKeyExclusive)
    {
        return TReadRange()
            .LowerLimit(TReadLimit().Key(lowerKeyInclusive))
            .UpperLimit(TReadLimit().Key(upperKeyExclusive));
    }
};

bool operator==(const TReadRange& lhs, const TReadRange& rhs) noexcept;

struct TRichYPath
{
    using TSelf = TRichYPath;

    FLUENT_FIELD(TYPath, Path);

    FLUENT_FIELD_OPTION(bool, Append);

    FLUENT_FIELD_OPTION(bool, PartiallySorted);

    FLUENT_FIELD(TSortColumns, SortedBy);

    TRichYPath& AddRange(TReadRange range)
    {
        if (!Ranges_) {
            Ranges_.ConstructInPlace();
        }
        Ranges_->push_back(std::move(range));
        return *this;
    }
 
    TRichYPath& ResetRanges()
    {
        Ranges_.Clear();
        return *this;
    }

    const TMaybe<TVector<TReadRange>>& GetRanges() const
    {
        return Ranges_;
    }
 
    TMaybe<TVector<TReadRange>>& MutableRanges()
    {
        return Ranges_;
    }

    TArrayRef<TReadRange> MutableRangesView()
    {
        if (Ranges_.Defined()) {
            return TArrayRef(Ranges_->data(), Ranges_->size());
        } else {
            return {};
        }
    }
 
    TArrayRef<const TReadRange> GetRangesView() const
    {
        if (Ranges_.Defined()) {
            return TArrayRef(Ranges_->data(), Ranges_->size());
        } else {
            return {};
        }
    }

    const TReadRange& GetRange(ssize_t i) const
    {
        return Ranges_.GetRef()[i];
    }
 
    TReadRange& MutableRange(ssize_t i)
    {
        return Ranges_.GetRef()[i];
    }

    FLUENT_FIELD_OPTION(TColumnNames, Columns);
 
    FLUENT_FIELD_OPTION(bool, Teleport);
    FLUENT_FIELD_OPTION(bool, Primary);
    FLUENT_FIELD_OPTION(bool, Foreign);
    FLUENT_FIELD_OPTION(i64, RowCountLimit);
 
    FLUENT_FIELD_OPTION(TString, FileName);

    FLUENT_FIELD_OPTION(TYPath, OriginalPath);

    FLUENT_FIELD_OPTION(bool, Executable);

    FLUENT_FIELD_OPTION(TNode, Format);

    FLUENT_FIELD_OPTION(TTableSchema, Schema);

    FLUENT_FIELD_OPTION(TString, CompressionCodec);

    FLUENT_FIELD_OPTION(EErasureCodecAttr, ErasureCodec);

    FLUENT_FIELD_OPTION(ESchemaModificationAttr, SchemaModification);

    FLUENT_FIELD_OPTION(EOptimizeForAttr, OptimizeFor);

    FLUENT_FIELD_OPTION(bool, BypassArtifactCache);

    FLUENT_FIELD_OPTION(i64, Timestamp);

    FLUENT_FIELD_OPTION(TTransactionId, TransactionId);

    FLUENT_FIELD_OPTION(bool, Create);
 
    using TRenameColumnsDescriptor = THashMap<TString, TString>;

    FLUENT_FIELD_OPTION(TRenameColumnsDescriptor, RenameColumns);

    FLUENT_FIELD_OPTION(TString, Cluster);

    FLUENT_FIELD_OPTION(TString, InputQuery);

    TRichYPath()
    { }

    TRichYPath(const char* path)
        : Path_(path)
    { }
 
    TRichYPath(const TYPath& path)
        : Path_(path)
    { }
 
private:
    TMaybe<TVector<TReadRange>> Ranges_;
};

template <typename TProtoType>
TRichYPath WithSchema(const TRichYPath& path, const TSortColumns& sortBy = TSortColumns())
{
    static_assert(std::is_base_of_v<::google::protobuf::Message, TProtoType>, "TProtoType must be Protobuf message");
 
    auto schemedPath = path;
    if (!schemedPath.Schema_) {
        schemedPath.Schema(CreateTableSchema<TProtoType>(sortBy));
    }
    return schemedPath;
}

template <typename TRowType>
TRichYPath MaybeWithSchema(const TRichYPath& path, const TSortColumns& sortBy = TSortColumns())
{
    if constexpr (std::is_base_of_v<::google::protobuf::Message, TRowType>) {
        return WithSchema<TRowType>(path, sortBy);
    } else {
        return path;
    }
}

const TVector<TReadRange>& GetRangesCompat(const TRichYPath& path);


struct TTableColumnarStatistics
{
    THashMap<TString, i64> ColumnDataWeight;

    THashMap<TString, ui64> ColumnEstimatedUniqueCounts;

    i64 LegacyChunksDataWeight = 0;

    TMaybe<i64> TimestampTotalWeight;
};


struct TMultiTablePartition
{
    struct TStatistics
    {
        i64 ChunkCount = 0;
        i64 DataWeight = 0;
        i64 RowCount = 0;
    };

    TVector<TRichYPath> TableRanges;

    TStatistics AggregateStatistics;

    TMaybe<TString> Cookie;
};

struct TMultiTablePartitions
{
    TVector<TMultiTablePartition> Partitions;
};


struct TFileReadRange
{
    using TSelf = TFileReadRange;
 
    FLUENT_FIELD_DEFAULT(i64, Begin, 0);

    FLUENT_FIELD_OPTION(i64, End);
};

struct TFilePartition
{
    TString Cookie;

    i64 Length = 0;
};

struct TFilePartitions
{
    TVector<TFilePartition> Partitions;
};


struct TTabletInfo
{
    i64 TotalRowCount = 0;

    i64 TrimmedRowCount = 0;

    ui64 BarrierTimestamp;
};


struct TAttributeFilter
{
    using TSelf = TAttributeFilter;

    FLUENT_VECTOR_FIELD(TString, Attribute);
};


bool IsTrivial(const TReadLimit& readLimit);

EValueType NodeTypeToValueType(TNode::EType nodeType);


enum class EMasterReadKind : int
{
    Leader /* "leader" */,

    Follower /* "follower" */,
    Cache /* "cache" */,
    MasterCache /* "master_cache" */,
};


namespace NDetail {
 
// MUST NOT BE USED BY CLIENTS
// TODO: we should use default GENERATE_ENUM_SERIALIZATION
TString ToString(EValueType type);
 
} // namespace NDetail

 
} // namespace NYT