cypress.h

Go to the documentation of this file.

#pragma once

 
#include "fwd.h"
 
#include "client_method_options.h"
#include "common.h"
#include "node.h"
 
#include <util/generic/maybe.h>
 
namespace NYT {


class ICypressClient
{
public:
    virtual ~ICypressClient() = default;

    virtual TNodeId Create(
        const TYPath& path,
        ENodeType type,
        const TCreateOptions& options = TCreateOptions()) = 0;

    template <typename TRowType>
    TNodeId CreateTable(
        const TYPath& path,
        const TSortColumns& sortColumns = TSortColumns(),
        const TCreateOptions& options = TCreateOptions());

    virtual void Remove(
        const TYPath& path,
        const TRemoveOptions& options = TRemoveOptions()) = 0;

    virtual bool Exists(
        const TYPath& path,
        const TExistsOptions& options = TExistsOptions()) = 0;

    virtual TNode Get(
        const TYPath& path,
        const TGetOptions& options = TGetOptions()) = 0;

    virtual void Set(
        const TYPath& path,
        const TNode& value,
        const TSetOptions& options = TSetOptions()) = 0;

    virtual void MultisetAttributes(
        const TYPath& path,
        const TNode::TMapType& attributes,
        const TMultisetAttributesOptions& options = TMultisetAttributesOptions()) = 0;

    virtual TNode::TListType List(
        const TYPath& path,
        const TListOptions& options = TListOptions()) = 0;

    virtual TNodeId Copy(
        const TYPath& sourcePath,
        const TYPath& destinationPath,
        const TCopyOptions& options = TCopyOptions()) = 0;

    virtual TNodeId Move(
        const TYPath& sourcePath,
        const TYPath& destinationPath,
        const TMoveOptions& options = TMoveOptions()) = 0;

    virtual TNodeId Link(
        const TYPath& targetPath,
        const TYPath& linkPath,
        const TLinkOptions& options = TLinkOptions()) = 0;

    virtual void Concatenate(
        const TVector<TRichYPath>& sourcePaths,
        const TRichYPath& destinationPath,
        const TConcatenateOptions& options = TConcatenateOptions()) = 0;

    virtual void Concatenate(
        const TVector<TYPath>& sourcePaths,
        const TYPath& destinationPath,
        const TConcatenateOptions& options = TConcatenateOptions());

    virtual TRichYPath CanonizeYPath(const TRichYPath& path) = 0;

    virtual TVector<TTableColumnarStatistics> GetTableColumnarStatistics(
        const TVector<TRichYPath>& paths,
        const TGetTableColumnarStatisticsOptions& options = {}) = 0;

    virtual TMultiTablePartitions GetTablePartitions(
        const TVector<TRichYPath>& paths,
        const TGetTablePartitionsOptions& options) = 0;

    virtual TFilePartitions GetFilePartitions(
        const TYPath& path,
        const TVector<TFileReadRange>& ranges,
        const TGetFilePartitionsOptions& options = {}) = 0;

    virtual TMaybe<TYPath> GetFileFromCache(
        const TString& md5Signature,
        const TYPath& cachePath,
        const TGetFileFromCacheOptions& options = TGetFileFromCacheOptions()) = 0;

    virtual TYPath PutFileToCache(
        const TYPath& filePath,
        const TString& md5Signature,
        const TYPath& cachePath,
        const TPutFileToCacheOptions& options = TPutFileToCacheOptions()) = 0;
};

 
template <typename TRowType>
TNodeId ICypressClient::CreateTable(
    const TYPath& path,
    const TSortColumns& sortColumns,
    const TCreateOptions& options)
{
    static_assert(
        std::is_base_of_v<::google::protobuf::Message, TRowType>,
        "TRowType must be inherited from google::protobuf::Message");
 
    TCreateOptions actualOptions = options;
    if (!actualOptions.Attributes_) {
        actualOptions.Attributes_ = TNode::CreateMap();
    }
 
    if (!actualOptions.Attributes_->HasKey("schema")) {
        actualOptions.Attributes_->AsMap().emplace(
            "schema",
            CreateTableSchema<TRowType>(sortColumns).ToNode());
    }
 
    return Create(path, ENodeType::NT_TABLE, actualOptions);
}

 
} // namespace NYT