client_method_options.h

Go to the documentation of this file.

#pragma once

 
#include "common.h"
#include "config.h"
#include "format.h"
#include "public.h"
#include "retry_policy.h"
 
#include <util/datetime/base.h>
 
namespace NYT {


enum ENodeType : int
{
    NT_STRING              =  0  /* "string_node" */,
    NT_INT64               =  1  /* "int64_node" */,
    NT_UINT64              =  2  /* "uint64_node" */,
    NT_DOUBLE              =  3  /* "double_node" */,
    NT_BOOLEAN             =  4  /* "boolean_node" */,
    NT_MAP                 =  5  /* "map_node" */,
    NT_LIST                =  6  /* DEPRECATED */,
    NT_FILE                =  7  /* "file" */,
    NT_TABLE               =  8  /* "table" */,
    NT_DOCUMENT            =  9  /* "document" */,
    NT_REPLICATED_TABLE    = 10  /* "replicated_table" */,
    NT_TABLE_REPLICA       = 11  /* "table_replica" */,
    NT_USER                = 12  /* "user" */,
    NT_SCHEDULER_POOL      = 13  /* "scheduler_pool" */,
    NT_LINK                = 14  /* "link" */,
    NT_GROUP               = 15  /* "group" */,
    NT_PORTAL              = 16  /* "portal_entrance" */,
    NT_CHAOS_TABLE_REPLICA = 17  /* "chaos_table_replica" */,
    NT_TABLE_COLLOCATION   = 18  /* "table_collocation" */,
};

enum class EComplexTypeMode : int
{
    Named /* "named" */,
    Positional /* "positional" */,
};

template <typename TDerived>
struct TSuppressableAccessTrackingOptions
{
    using TSelf = TDerived;

    FLUENT_FIELD_DEFAULT(bool, SuppressAccessTracking, false);

    FLUENT_FIELD_DEFAULT(bool, SuppressModificationTracking, false);
};

struct TPrerequisiteRevision
{
    using TSelf = TPrerequisiteRevision;

    FLUENT_FIELD_OPTION(TYPath, Path);

    FLUENT_FIELD_OPTION(ui64, Revision);
};

template <typename TDerived>
struct TPrerequisiteTransactionsOptions
{
    using TSelf = TDerived;

    FLUENT_VECTOR_FIELD(TTransactionId, PrerequisiteTransactionId);
};

template <typename TDerived>
struct TPrerequisiteRevisionsOptions
{
    using TSelf = TDerived;

    FLUENT_VECTOR_FIELD(TPrerequisiteRevision, PrerequisiteRevision);
};

template <typename TDerived>
struct TPrerequisiteOptions
    : public TPrerequisiteRevisionsOptions<TDerived>
    , public TPrerequisiteTransactionsOptions<TDerived>
{ };

struct TCreateOptions
    : public TPrerequisiteOptions<TCreateOptions>
{
    using TSelf = TCreateOptions;

    FLUENT_FIELD_DEFAULT(bool, Recursive, false);

    FLUENT_FIELD_DEFAULT(bool, IgnoreExisting, false);

    FLUENT_FIELD_DEFAULT(bool, IgnoreTypeMismatch, false);

    FLUENT_FIELD_DEFAULT(bool, Force, false);

    FLUENT_FIELD_OPTION(TNode, Attributes);
};

struct TRemoveOptions
    : public TPrerequisiteOptions<TRemoveOptions>
{
    using TSelf = TRemoveOptions;

    FLUENT_FIELD_DEFAULT(bool, Recursive, false);

    FLUENT_FIELD_DEFAULT(bool, Force, false);
};

template <typename TDerived>
struct TMasterReadOptions
{
    using TSelf = TDerived;

    FLUENT_FIELD_OPTION(EMasterReadKind, ReadFrom);
};

struct TExistsOptions
    : public TMasterReadOptions<TExistsOptions>
    , public TSuppressableAccessTrackingOptions<TExistsOptions>
    , public TPrerequisiteOptions<TExistsOptions>
{ };

struct TGetOptions
    : public TMasterReadOptions<TGetOptions>
    , public TSuppressableAccessTrackingOptions<TGetOptions>
    , public TPrerequisiteOptions<TGetOptions>
{
    FLUENT_FIELD_OPTION(TAttributeFilter, AttributeFilter);

    FLUENT_FIELD_OPTION(i64, MaxSize);
};

struct TSetOptions
    : public TSuppressableAccessTrackingOptions<TSetOptions>
    , public TPrerequisiteOptions<TSetOptions>
{
    using TSelf = TSetOptions;

    FLUENT_FIELD_DEFAULT(bool, Recursive, false);

    FLUENT_FIELD_OPTION(bool, Force);
};

struct TMultisetAttributesOptions
    : public TSuppressableAccessTrackingOptions<TMultisetAttributesOptions>
    , public TPrerequisiteOptions<TMultisetAttributesOptions>
{
    using TSelf = TMultisetAttributesOptions;
 
    FLUENT_FIELD_OPTION(bool, Force);
};

struct TListOptions
    : public TMasterReadOptions<TListOptions>
    , public TSuppressableAccessTrackingOptions<TListOptions>
    , public TPrerequisiteOptions<TListOptions>
{
    using TSelf = TListOptions;

    FLUENT_FIELD_OPTION(TAttributeFilter, AttributeFilter);

    FLUENT_FIELD_OPTION(i64, MaxSize);
};

struct TCopyOptions
    : public TPrerequisiteOptions<TCopyOptions>
{
    using TSelf = TCopyOptions;

    FLUENT_FIELD_DEFAULT(bool, Recursive, false);

    FLUENT_FIELD_DEFAULT(bool, Force, false);

    FLUENT_FIELD_DEFAULT(bool, PreserveAccount, false);

    FLUENT_FIELD_OPTION(bool, PreserveExpirationTime);
};

struct TMoveOptions
    : public TPrerequisiteOptions<TMoveOptions>
{
    using TSelf = TMoveOptions;

    FLUENT_FIELD_DEFAULT(bool, Recursive, false);

    FLUENT_FIELD_DEFAULT(bool, Force, false);

    FLUENT_FIELD_DEFAULT(bool, PreserveAccount, false);

    FLUENT_FIELD_OPTION(bool, PreserveExpirationTime);
};

struct TLinkOptions
    : public TPrerequisiteOptions<TLinkOptions>
{
    using TSelf = TLinkOptions;

    FLUENT_FIELD_DEFAULT(bool, Recursive, false);

    FLUENT_FIELD_DEFAULT(bool, IgnoreExisting, false);

    FLUENT_FIELD_DEFAULT(bool, Force, false);

    FLUENT_FIELD_OPTION(TNode, Attributes);
};

struct TConcatenateOptions
{
    using TSelf = TConcatenateOptions;

    FLUENT_FIELD_OPTION(bool, Append);
 
    // Maximum number of items to process in single concat request.
    //
    // If number of items provided is greater then this parameter
    // client might split concatenate to several requests.
    FLUENT_FIELD_DEFAULT(int, MaxBatchSize, 20);
};

struct TBlobTableReaderOptions
    : public TSuppressableAccessTrackingOptions<TBlobTableReaderOptions>
{
    using TSelf = TBlobTableReaderOptions;

    FLUENT_FIELD_OPTION(TString, PartIndexColumnName);

    FLUENT_FIELD_OPTION(TString, DataColumnName);

    FLUENT_FIELD_DEFAULT(i64, PartSize, 4 * 1024 * 1024);

    FLUENT_FIELD_DEFAULT(i64, StartPartIndex, 0);

    FLUENT_FIELD_DEFAULT(i64, Offset, 0);
};

struct TResourceLimits
{
    using TSelf = TResourceLimits;

    FLUENT_FIELD_OPTION(i64, UserSlots);

    FLUENT_FIELD_OPTION(double, Cpu);

    FLUENT_FIELD_OPTION(i64, Network);

    FLUENT_FIELD_OPTION(i64, Memory);
};

struct TSchedulingOptions
{
    using TSelf = TSchedulingOptions;

    FLUENT_FIELD_OPTION(TString, Pool);

    FLUENT_FIELD_OPTION(double, Weight);

    FLUENT_FIELD_OPTION(TResourceLimits, ResourceLimits);
};

struct TSchedulingOptionsPerPoolTree
{
    using TSelf = TSchedulingOptionsPerPoolTree;
 
    TSchedulingOptionsPerPoolTree(const THashMap<TString, TSchedulingOptions>& options = {})
        : Options_(options)
    { }

    TSelf& Add(TStringBuf poolTreeName, const TSchedulingOptions& schedulingOptions)
    {
        Y_ENSURE(Options_.emplace(poolTreeName, schedulingOptions).second);
        return *this;
    }
 
    THashMap<TString, TSchedulingOptions> Options_;
};

struct TSuspendOperationOptions
{
    using TSelf = TSuspendOperationOptions;

    FLUENT_FIELD_OPTION(bool, AbortRunningJobs);

    FLUENT_FIELD_OPTION(std::optional<TString>, Reason);
};

struct TResumeOperationOptions
{
    using TSelf = TResumeOperationOptions;
};

struct TUpdateOperationParametersOptions
{
    using TSelf = TUpdateOperationParametersOptions;

    FLUENT_VECTOR_FIELD(TString, Owner);

    FLUENT_FIELD_OPTION(TString, Pool);

    FLUENT_FIELD_OPTION(double, Weight);

    FLUENT_FIELD_OPTION(TSchedulingOptionsPerPoolTree, SchedulingOptionsPerPoolTree);
};

template <class TDerived>
struct TIOOptions
{
    using TSelf = TDerived;

    FLUENT_FIELD_OPTION(TNode, Config);

    FLUENT_FIELD_DEFAULT(bool, CreateTransaction, true);
};

struct TFileReaderOptions
    : public TIOOptions<TFileReaderOptions>
    , public TSuppressableAccessTrackingOptions<TFileReaderOptions>
{
    FLUENT_FIELD_DEFAULT(i64, Offset, 0);

    FLUENT_FIELD_OPTION(i64, Length);
};

struct TFilePartitionReaderOptions
{
    using TSelf = TFilePartitionReaderOptions;

    FLUENT_FIELD_OPTION(TNode, Config);
};

struct TWriterOptions
{
    using TSelf = TWriterOptions;

    FLUENT_FIELD_OPTION(bool, EnableEarlyFinish);

    FLUENT_FIELD_OPTION(ui64, UploadReplicationFactor);

    FLUENT_FIELD_OPTION(ui64, MinUploadReplicationFactor);

    FLUENT_FIELD_OPTION(ui64, DesiredChunkSize);

    FLUENT_FIELD_OPTION(size_t, RetryBlockSize);
};

struct TFileWriterOptions
    : public TIOOptions<TFileWriterOptions>
{
    FLUENT_FIELD_OPTION(bool, ComputeMD5);

    FLUENT_FIELD_DEFAULT(bool, AutoFinish, true);

    FLUENT_FIELD_OPTION(TWriterOptions, WriterOptions);
};

struct TFileFragmentWriterOptions
{ };
 
class TSkiffRowHints
{
public:
    using TSelf = TSkiffRowHints;

    FLUENT_FIELD_OPTION(TNode, Attributes);

    FLUENT_FIELD_OPTION(int, TableIndex);
};

class TFormatHints
{
public:
    using TSelf = TFormatHints;

    FLUENT_FIELD_DEFAULT(bool, SkipNullValuesForTNode, false);

    FLUENT_FIELD_OPTION(bool, EnableStringToAllConversion);

    FLUENT_FIELD_OPTION(bool, EnableAllToStringConversion);

    FLUENT_FIELD_OPTION(bool, EnableIntegralTypeConversion);

    FLUENT_FIELD_OPTION(bool, EnableIntegralToDoubleConversion);

    FLUENT_FIELD_OPTION(bool, EnableTypeConversion);

    FLUENT_FIELD_OPTION(EComplexTypeMode, ComplexTypeMode);

    FLUENT_FIELD_OPTION(TSkiffRowHints, SkiffRowHints);

    void Merge(const TFormatHints& patch);
};

class TControlAttributes
{
public:
    using TSelf = TControlAttributes;

    FLUENT_FIELD_DEFAULT(bool, EnableRowIndex, true);

    FLUENT_FIELD_DEFAULT(bool, EnableRangeIndex, true);
};

struct TTableReaderOptions
    : public TIOOptions<TTableReaderOptions>
    , public TSuppressableAccessTrackingOptions<TTableReaderOptions>
{
    FLUENT_FIELD_DEFAULT(size_t, SizeLimit, 4 << 20);

    FLUENT_FIELD_OPTION(TFormatHints, FormatHints);

    FLUENT_FIELD_DEFAULT(TControlAttributes, ControlAttributes, TControlAttributes());

    FLUENT_FIELD_DEFAULT(bool, OmitInaccessibleRows, false);
};

struct TTablePartitionReaderOptions
    : public TSuppressableAccessTrackingOptions<TTablePartitionReaderOptions>
{
    using TSelf = TTablePartitionReaderOptions;

    FLUENT_FIELD_OPTION(TFormatHints, FormatHints);

    FLUENT_FIELD_DEFAULT(TControlAttributes, ControlAttributes, TControlAttributes());
};

struct TTableWriterOptions
    : public TIOOptions<TTableWriterOptions>
{
    FLUENT_FIELD_DEFAULT(bool, SingleHttpRequest, false);

    FLUENT_FIELD_DEFAULT(size_t, BufferSize, 64 << 20);

    FLUENT_FIELD_OPTION(TFormatHints, FormatHints);

    FLUENT_FIELD_OPTION(bool, InferSchema);

    FLUENT_FIELD_DEFAULT(bool, AutoFinish, true);

    FLUENT_FIELD_OPTION(TWriterOptions, WriterOptions);
};

struct TTableFragmentWriterOptions
{ };

struct TStartTransactionOptions
    : public TPrerequisiteTransactionsOptions<TStartTransactionOptions>
{
    using TSelf = TStartTransactionOptions;
 
    FLUENT_FIELD_DEFAULT(bool, PingAncestors, false);

    FLUENT_FIELD_OPTION(TDuration, Timeout);

    FLUENT_FIELD_OPTION(TInstant, Deadline);

    FLUENT_FIELD_DEFAULT(bool, AutoPingable, true);

    FLUENT_FIELD_OPTION(TString, Title);

    FLUENT_FIELD_OPTION(TNode, Attributes);
};

struct TAttachTransactionOptions
{
    using TSelf = TAttachTransactionOptions;

    FLUENT_FIELD_DEFAULT(bool, AutoPingable, false);

    FLUENT_FIELD_DEFAULT(bool, AbortOnTermination, false);
};

enum ELockMode : int
{
    LM_EXCLUSIVE    /* "exclusive" */,

    LM_SHARED       /* "shared" */,

    LM_SNAPSHOT     /* "snapshot" */,
};

struct TLockOptions
    : public TPrerequisiteOptions<TLockOptions>
{
    using TSelf = TLockOptions;

    FLUENT_FIELD_DEFAULT(bool, Waitable, false);

    FLUENT_FIELD_OPTION(TString, AttributeKey);

    FLUENT_FIELD_OPTION(TString, ChildKey);
};

struct TUnlockOptions
    : public TPrerequisiteOptions<TUnlockOptions>
{
    using TSelf = TUnlockOptions;
};

struct TCommitTransactionOptions
    : public TPrerequisiteOptions<TCommitTransactionOptions>
{
    using TSelf = TCommitTransactionOptions;
};

template <class TDerived>
struct TTabletOptions
{
    using TSelf = TDerived;

    FLUENT_FIELD_OPTION(i64, FirstTabletIndex);

    FLUENT_FIELD_OPTION(i64, LastTabletIndex);
};

struct TMountTableOptions
    : public TTabletOptions<TMountTableOptions>
{
    using TSelf = TMountTableOptions;

    FLUENT_FIELD_OPTION(TTabletCellId, CellId);

    FLUENT_FIELD_DEFAULT(bool, Freeze, false);
};

struct TUnmountTableOptions
    : public TTabletOptions<TUnmountTableOptions>
{
    using TSelf = TUnmountTableOptions;

    FLUENT_FIELD_DEFAULT(bool, Force, false);
};

struct TRemountTableOptions
    : public TTabletOptions<TRemountTableOptions>
{ };

struct TReshardTableOptions
    : public TTabletOptions<TReshardTableOptions>
{ };

struct TFreezeTableOptions
    : public TTabletOptions<TFreezeTableOptions>
{ };

struct TUnfreezeTableOptions
    : public TTabletOptions<TUnfreezeTableOptions>
{ };

struct TAlterTableOptions
{
    using TSelf = TAlterTableOptions;

    FLUENT_FIELD_OPTION(TTableSchema, Schema);

    FLUENT_FIELD_OPTION(bool, Dynamic);

    FLUENT_FIELD_OPTION(TReplicaId, UpstreamReplicaId);
};

struct TLookupRowsOptions
{
    using TSelf = TLookupRowsOptions;

    FLUENT_FIELD_OPTION(TDuration, Timeout);

    FLUENT_FIELD_OPTION(TColumnNames, Columns);

    FLUENT_FIELD_DEFAULT(bool, KeepMissingRows, false);

    FLUENT_FIELD_DEFAULT(bool, Versioned, false);
};

struct TSelectRowsOptions
    : public TSuppressableAccessTrackingOptions<TSelectRowsOptions>
{
    using TSelf = TSelectRowsOptions;

    FLUENT_FIELD_OPTION(TDuration, Timeout);

    FLUENT_FIELD_OPTION(i64, InputRowLimit);

    FLUENT_FIELD_OPTION(i64, OutputRowLimit);

    FLUENT_FIELD_DEFAULT(ui64, RangeExpansionLimit, 1000);

    FLUENT_FIELD_DEFAULT(bool, FailOnIncompleteResult, true);

    FLUENT_FIELD_DEFAULT(bool, VerboseLogging, false);
 
    FLUENT_FIELD_DEFAULT(bool, EnableCodeCache, true);
};

struct TCreateClientOptions
{
    using TSelf = TCreateClientOptions;

    FLUENT_FIELD_OPTION(TString, ImpersonationUser);

    FLUENT_FIELD(TString, Token);

    FLUENT_FIELD(TString, TokenPath);

    NAuth::IServiceTicketAuthPtrWrapperPtr ServiceTicketAuth_ = nullptr;
    TSelf& ServiceTicketAuth(const NAuth::IServiceTicketAuthPtrWrapper& wrapper);

    FLUENT_FIELD_DEFAULT(bool, TvmOnly, false);

    FLUENT_FIELD_OPTION(bool, UseTLS);

    FLUENT_FIELD_DEFAULT(bool, UseCoreHttpClient, false);

    FLUENT_FIELD_DEFAULT(IRetryConfigProviderPtr, RetryConfigProvider, nullptr);

    FLUENT_FIELD_DEFAULT(TConfigPtr, Config, nullptr);

    FLUENT_FIELD_OPTION(TString, ProxyAddress);

    FLUENT_FIELD_OPTION(TString, JobProxySocketPath);
};

struct TExecuteBatchOptions
{
    using TSelf = TExecuteBatchOptions;

    FLUENT_FIELD_OPTION(ui64, Concurrency);

    FLUENT_FIELD_OPTION(ui64, BatchPartMaxSize);
};

enum class EDurability
{
    Sync    /* "sync" */,

    Async   /* "async" */,
};

enum class EAtomicity
{
    None    /* "none" */,

    Full    /* "full" */,
};

enum class ETableReplicaMode
{
    Sync    /* "sync" */,
    Async   /* "async" */,
};

enum class ELockType
{
    Exclusive   /* "exclusive" */,

    SharedWrite /* "shared_write" */,
};

template <typename TDerived>
struct TTabletTransactionOptions
{
    using TSelf = TDerived;

    FLUENT_FIELD_OPTION(EAtomicity, Atomicity);

    FLUENT_FIELD_OPTION(EDurability, Durability);
};

struct TInsertRowsOptions
    : public TTabletTransactionOptions<TInsertRowsOptions>
{
    FLUENT_FIELD_OPTION(bool, Update);

    FLUENT_FIELD_OPTION(bool, Aggregate);

    FLUENT_FIELD_OPTION(bool, RequireSyncReplica);

    FLUENT_FIELD_OPTION(ELockType, LockType);
};

struct TDeleteRowsOptions
    : public TTabletTransactionOptions<TDeleteRowsOptions>
{
    // Used for delete operation for tables without sync replica.
    // Default value is 'false'. So deletion into table without sync replicas fails.
    FLUENT_FIELD_OPTION(bool, RequireSyncReplica);
};

struct TTrimRowsOptions
    : public TTabletTransactionOptions<TTrimRowsOptions>
{ };

struct TAlterTableReplicaOptions
{
    using TSelf = TAlterTableReplicaOptions;

    FLUENT_FIELD_OPTION(bool, Enabled);

    FLUENT_FIELD_OPTION(ETableReplicaMode, Mode);
};

struct TGetFileFromCacheOptions
{
    using TSelf = TGetFileFromCacheOptions;
};

struct TPutFileToCacheOptions
{
    using TSelf = TPutFileToCacheOptions;

    FLUENT_FIELD_OPTION(bool, PreserveExpirationTimeout);
};

enum class EPermission : int
{
    Read         /* "read" */,

    Write        /* "write" */,

    Use          /* "use" */,

    Administer   /* "administer" */,

    Create       /* "create" */,

    Remove       /* "remove" */,

    Mount        /* "mount" */,

    Manage       /* "manage" */,

    FullRead     /* "full_read" */,
};

enum class ESecurityAction : int
{
    Allow /* "allow" */,

    Deny  /* "deny" */,
};

struct TCheckPermissionOptions
{
    using TSelf = TCheckPermissionOptions;

    FLUENT_VECTOR_FIELD(TString, Column);
};

enum class EColumnarStatisticsFetcherMode
{
    FromNodes /* "from_nodes" */,

    FromMaster /* "from_master" */,

    Fallback /* "fallback" */,
};

struct TGetTableColumnarStatisticsOptions
{
    using TSelf = TGetTableColumnarStatisticsOptions;

    FLUENT_FIELD_OPTION(EColumnarStatisticsFetcherMode, FetcherMode);
};

enum class ETablePartitionMode
{
    Unordered /* "unordered" */,

    Ordered /* "ordered" */,
};

struct TGetTablePartitionsOptions
{
    using TSelf = TGetTablePartitionsOptions;

    FLUENT_FIELD(ETablePartitionMode, PartitionMode);

    FLUENT_FIELD(i64, DataWeightPerPartition);

    FLUENT_FIELD_OPTION(int, MaxPartitionCount);

    FLUENT_FIELD_DEFAULT(bool, AdjustDataWeightPerPartition, true);

    FLUENT_FIELD_DEFAULT(bool, EnableCookies, false);

    FLUENT_FIELD_DEFAULT(bool, FetchCookieNodeDescriptors, false);
};

struct TGetFilePartitionsOptions
    : public TSuppressableAccessTrackingOptions<TGetFilePartitionsOptions>
{
    using TSelf = TGetFilePartitionsOptions;

    FLUENT_FIELD_DEFAULT(bool, FetchCookieNodeDescriptors, true);
};

struct TGetTabletInfosOptions
{
    using TSelf = TGetTabletInfosOptions;
};

struct TSkyShareTableOptions
{
    using TSelf = TSkyShareTableOptions;

    FLUENT_FIELD_OPTION(TColumnNames, KeyColumns);

    FLUENT_FIELD_OPTION(bool, EnableFastbone);

    FLUENT_FIELD_OPTION(TString, Pool);
};

struct TCheckClusterLivenessOptions
{
    using TSelf = TCheckClusterLivenessOptions;

    FLUENT_FIELD_DEFAULT(bool, CheckCypressRoot, true);

    FLUENT_FIELD_DEFAULT(bool, CheckSecondaryMasterCells, true);

    FLUENT_FIELD_OPTION(TString, CheckTabletCellBundle);
};

 
} // namespace NYT