[yt/cpp/mapreduce] YT-23616: Move Transaction, Misc, Table methods to THttpRawClient

commit_hash:a08daac218b8d8bbd805220429b62f2284ad094f

11 files changed, 471 insertions, 411 deletions

diff --git a/yt/cpp/mapreduce/client/abortable_registry.cpp b/yt/cpp/mapreduce/client/abortable_registry.cpp
index 91308cba057..2150398aa95 100644
--- a/yt/cpp/mapreduce/client/abortable_registry.cpp
+++ b/yt/cpp/mapreduce/client/abortable_registry.cpp
@@ -11,21 +11,26 @@
 
 #include <util/generic/singleton.h>
 
-namespace NYT {
-namespace NDetail {
-
-using namespace NRawClient;
+namespace NYT::NDetail {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-TTransactionAbortable::TTransactionAbortable(const TClientContext& context, const TTransactionId& transactionId)
-    : Context_(context)
+TTransactionAbortable::TTransactionAbortable(
+    const IRawClientPtr& rawClient,
+    const TClientContext& context,
+    const TTransactionId& transactionId)
+    : RawClient_(rawClient)
+    , Context_(context)
     , TransactionId_(transactionId)
 { }
 
 void TTransactionAbortable::Abort()
 {
-    AbortTransaction(nullptr, Context_, TransactionId_);
+    RequestWithRetry<void>(
+        CreateDefaultRequestRetryPolicy(Context_.Config),
+        [this] (TMutationId& mutationId) {
+            RawClient_->AbortTransaction(mutationId, TransactionId_);
+        });
 }
 
 TString TTransactionAbortable::GetType() const
@@ -131,5 +136,4 @@ private:
 
 ////////////////////////////////////////////////////////////////////////////////
 
-} // namespace NDetail
-} // namespace NYT
+} // namespace NYT::NDetail
diff --git a/yt/cpp/mapreduce/client/abortable_registry.h b/yt/cpp/mapreduce/client/abortable_registry.h
index 7d8996405ef..b19c802f985 100644
--- a/yt/cpp/mapreduce/client/abortable_registry.h
+++ b/yt/cpp/mapreduce/client/abortable_registry.h
@@ -31,13 +31,17 @@ class TTransactionAbortable
     : public IAbortable
 {
 public:
-    TTransactionAbortable(const TClientContext& context, const TTransactionId& transactionId);
+    TTransactionAbortable(
+        const IRawClientPtr& rawClient,
+        const TClientContext& context,
+        const TTransactionId& transactionId);
     void Abort() override;
     TString GetType() const override;
 
 private:
-    TClientContext Context_;
-    TTransactionId TransactionId_;
+    const IRawClientPtr RawClient_;
+    const TClientContext Context_;
+    const TTransactionId TransactionId_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/yt/cpp/mapreduce/client/client.cpp b/yt/cpp/mapreduce/client/client.cpp
index b7fbb7f0807..9e3976b144b 100644
--- a/yt/cpp/mapreduce/client/client.cpp
+++ b/yt/cpp/mapreduce/client/client.cpp
@@ -283,24 +283,22 @@ TVector<TTableColumnarStatistics> TClientBase::GetTableColumnarStatistics(
     const TVector<TRichYPath>& paths,
     const TGetTableColumnarStatisticsOptions& options)
 {
-    return NRawClient::GetTableColumnarStatistics(
+    return RequestWithRetry<TVector<TTableColumnarStatistics>>(
         ClientRetryPolicy_->CreatePolicyForGenericRequest(),
-        Context_,
-        TransactionId_,
-        paths,
-        options);
+        [this, &paths, &options] (TMutationId /*mutationId*/) {
+            return RawClient_->GetTableColumnarStatistics(TransactionId_, paths, options);
+        });
 }
 
 TMultiTablePartitions TClientBase::GetTablePartitions(
     const TVector<TRichYPath>& paths,
     const TGetTablePartitionsOptions& options)
 {
-    return NRawClient::GetTablePartitions(
+    return RequestWithRetry<TMultiTablePartitions>(
         ClientRetryPolicy_->CreatePolicyForGenericRequest(),
-        Context_,
-        TransactionId_,
-        paths,
-        options);
+        [this, &paths, &options] (TMutationId /*mutationId*/) {
+            return RawClient_->GetTablePartitions(TransactionId_, paths, options);
+        });
 }
 
 TMaybe<TYPath> TClientBase::GetFileFromCache(
@@ -308,7 +306,11 @@ TMaybe<TYPath> TClientBase::GetFileFromCache(
     const TYPath& cachePath,
     const TGetFileFromCacheOptions& options)
 {
-    return NRawClient::GetFileFromCache(ClientRetryPolicy_->CreatePolicyForGenericRequest(), Context_, TransactionId_, md5Signature, cachePath, options);
+    return RequestWithRetry<TMaybe<TYPath>>(
+        ClientRetryPolicy_->CreatePolicyForGenericRequest(),
+        [this, &md5Signature, &cachePath, &options] (TMutationId /*mutationId*/) {
+            return RawClient_->GetFileFromCache(TransactionId_, md5Signature, cachePath, options);
+        });
 }
 
 TYPath TClientBase::PutFileToCache(
@@ -317,7 +319,11 @@ TYPath TClientBase::PutFileToCache(
     const TYPath& cachePath,
     const TPutFileToCacheOptions& options)
 {
-    return NRawClient::PutFileToCache(ClientRetryPolicy_->CreatePolicyForGenericRequest(), Context_, TransactionId_, filePath, md5Signature, cachePath, options);
+    return RequestWithRetry<TYPath>(
+        ClientRetryPolicy_->CreatePolicyForGenericRequest(),
+        [this, &filePath, &md5Signature, &cachePath, &options] (TMutationId /*mutationId*/) {
+            return RawClient_->PutFileToCache(TransactionId_, filePath, md5Signature, cachePath, options);
+        });
 }
 
 IFileReaderPtr TClientBase::CreateBlobTableReader(
@@ -739,7 +745,11 @@ void TClientBase::AlterTable(
     const TYPath& path,
     const TAlterTableOptions& options)
 {
-    NRawClient::AlterTable(ClientRetryPolicy_->CreatePolicyForGenericRequest(), Context_, TransactionId_, path, options);
+    RequestWithRetry<void>(
+        ClientRetryPolicy_->CreatePolicyForGenericRequest(),
+        [this, &path, &options] (TMutationId& mutationId) {
+            RawClient_->AlterTable(mutationId, TransactionId_, path, options);
+        });
 }
 
 ::TIntrusivePtr<TClientReader> TClientBase::CreateClientReader(
@@ -1005,7 +1015,7 @@ void TTransaction::Ping()
     RequestWithRetry<void>(
         ClientRetryPolicy_->CreatePolicyForGenericRequest(),
         [this] (TMutationId /*mutationId*/) {
-            RawClient_->PingTx(TransactionId_);
+            RawClient_->PingTransaction(TransactionId_);
         });
 }
 
@@ -1087,7 +1097,11 @@ void TClient::FreezeTable(
     const TFreezeTableOptions& options)
 {
     CheckShutdown();
-    NRawClient::FreezeTable(ClientRetryPolicy_->CreatePolicyForGenericRequest(), Context_, path, options);
+    RequestWithRetry<void>(
+        ClientRetryPolicy_->CreatePolicyForGenericRequest(),
+        [this, &path, &options] (TMutationId /*mutationId*/) {
+            RawClient_->FreezeTable(path, options);
+        });
 }
 
 void TClient::UnfreezeTable(
@@ -1095,7 +1109,11 @@ void TClient::UnfreezeTable(
     const TUnfreezeTableOptions& options)
 {
     CheckShutdown();
-    NRawClient::UnfreezeTable(ClientRetryPolicy_->CreatePolicyForGenericRequest(), Context_, path, options);
+    RequestWithRetry<void>(
+        ClientRetryPolicy_->CreatePolicyForGenericRequest(),
+        [this, &path, &options] (TMutationId /*mutationId*/) {
+            RawClient_->UnfreezeTable(path, options);
+        });
 }
 
 void TClient::ReshardTable(
@@ -1143,7 +1161,11 @@ void TClient::DeleteRows(
     const TDeleteRowsOptions& options)
 {
     CheckShutdown();
-    return NRawClient::DeleteRows(ClientRetryPolicy_->CreatePolicyForGenericRequest(), Context_, path, keys, options);
+    RequestWithRetry<void>(
+        ClientRetryPolicy_->CreatePolicyForGenericRequest(),
+        [this, &path, &keys, &options] (TMutationId /*mutationId*/) {
+            RawClient_->DeleteRows(path, keys, options);
+        });
 }
 
 void TClient::TrimRows(
@@ -1188,7 +1210,11 @@ TNode::TListType TClient::SelectRows(
 void TClient::AlterTableReplica(const TReplicaId& replicaId, const TAlterTableReplicaOptions& options)
 {
     CheckShutdown();
-    NRawClient::AlterTableReplica(ClientRetryPolicy_->CreatePolicyForGenericRequest(), Context_, replicaId, options);
+    RequestWithRetry<void>(
+        ClientRetryPolicy_->CreatePolicyForGenericRequest(),
+        [this, &replicaId, &options] (TMutationId& mutationId) {
+            RawClient_->AlterTableReplica(mutationId, replicaId, options);
+        });
 }
 
 ui64 TClient::GenerateTimestamp()
@@ -1340,7 +1366,11 @@ TCheckPermissionResponse TClient::CheckPermission(
     const TCheckPermissionOptions& options)
 {
     CheckShutdown();
-    return NRawClient::CheckPermission(ClientRetryPolicy_->CreatePolicyForGenericRequest(), Context_, user, permission, path, options);
+    return RequestWithRetry<TCheckPermissionResponse>(
+        ClientRetryPolicy_->CreatePolicyForGenericRequest(),
+        [this, &user, &permission, &path, &options] (TMutationId /*mutationId*/) {
+            return RawClient_->CheckPermission(user, permission, path, options);
+        });
 }
 
 TVector<TTabletInfo> TClient::GetTabletInfos(
@@ -1349,10 +1379,13 @@ TVector<TTabletInfo> TClient::GetTabletInfos(
     const TGetTabletInfosOptions& options)
 {
     CheckShutdown();
-    return NRawClient::GetTabletInfos(ClientRetryPolicy_->CreatePolicyForGenericRequest(), Context_, path, tabletIndexes, options);
+    return RequestWithRetry<TVector<TTabletInfo>>(
+        ClientRetryPolicy_->CreatePolicyForGenericRequest(),
+        [this, &path, &tabletIndexes, &options] (TMutationId /*mutationId*/) {
+            return RawClient_->GetTabletInfos(path, tabletIndexes, options);
+        });
 }
 
-
 void TClient::SuspendOperation(
     const TOperationId& operationId,
     const TSuspendOperationOptions& options)
diff --git a/yt/cpp/mapreduce/client/operation_preparer.cpp b/yt/cpp/mapreduce/client/operation_preparer.cpp
index a3944620f2b..e8e4ee26d2f 100644
--- a/yt/cpp/mapreduce/client/operation_preparer.cpp
+++ b/yt/cpp/mapreduce/client/operation_preparer.cpp
@@ -31,8 +31,6 @@
 
 namespace NYT::NDetail {
 
-using namespace NRawClient;
-
 ////////////////////////////////////////////////////////////////////////////////
 
 class TWaitOperationStartPollerItem
@@ -44,7 +42,7 @@ public:
         , Transaction_(std::move(transaction))
     { }
 
-    void PrepareRequest(TRawBatchRequest* batchRequest) override
+    void PrepareRequest(NRawClient::TRawBatchRequest* batchRequest) override
     {
         Future_ = batchRequest->GetOperation(
             OperationId_,
@@ -224,7 +222,7 @@ void TOperationPreparer::LockFiles(TVector<TRichYPath>* paths)
 
     TVector<::NThreading::TFuture<TLockId>> lockIdFutures;
     lockIdFutures.reserve(paths->size());
-    TRawBatchRequest lockRequest(GetContext().Config);
+    NRawClient::TRawBatchRequest lockRequest(GetContext().Config);
     for (const auto& path : *paths) {
         lockIdFutures.push_back(lockRequest.Lock(
             FileTransaction_->GetId(),
@@ -236,7 +234,7 @@ void TOperationPreparer::LockFiles(TVector<TRichYPath>* paths)
 
     TVector<::NThreading::TFuture<TNode>> nodeIdFutures;
     nodeIdFutures.reserve(paths->size());
-    TRawBatchRequest getNodeIdRequest(GetContext().Config);
+    NRawClient::TRawBatchRequest getNodeIdRequest(GetContext().Config);
     for (const auto& lockIdFuture : lockIdFutures) {
         nodeIdFutures.push_back(getNodeIdRequest.Get(
             FileTransaction_->GetId(),
@@ -405,7 +403,7 @@ TJobPreparer::TJobPreparer(
 {
 
     CreateStorage();
-    auto cypressFileList = CanonizeYPaths(/* retryPolicy */ nullptr, OperationPreparer_.GetContext(), spec.Files_);
+    auto cypressFileList = NRawClient::CanonizeYPaths(/* retryPolicy */ nullptr, OperationPreparer_.GetContext(), spec.Files_);
 
     for (const auto& file : cypressFileList) {
         UseFileInCypress(file);
@@ -545,19 +543,16 @@ TString TJobPreparer::PutFileToCypressCache(
         LockConflictRetryCount,
         OperationPreparer_.GetContext().Config);
 
-    auto putFileToCacheOptions = TPutFileToCacheOptions();
+    auto options = TPutFileToCacheOptions();
     if (Options_.FileExpirationTimeout_) {
-        putFileToCacheOptions.PreserveExpirationTimeout(true);
+        options.PreserveExpirationTimeout(true);
     }
 
-    auto cachePath = PutFileToCache(
+    auto cachePath = RequestWithRetry<TYPath>(
         retryPolicy,
-        OperationPreparer_.GetContext(),
-        transactionId,
-        path,
-        md5Signature,
-        GetCachePath(),
-        putFileToCacheOptions);
+        [this, &path, &md5Signature, &transactionId, &options] (TMutationId /*mutationId*/) {
+            return RawClient_->PutFileToCache(transactionId, path, md5Signature, GetCachePath(), options);
+        });
 
     RequestWithRetry<void>(
         OperationPreparer_.GetClientRetryPolicy()->CreatePolicyForGenericRequest(),
@@ -574,13 +569,12 @@ TMaybe<TString> TJobPreparer::GetItemFromCypressCache(const TString& md5Signatur
     auto retryPolicy = MakeIntrusive<TRetryPolicyIgnoringLockConflicts>(
         LockConflictRetryCount,
         OperationPreparer_.GetContext().Config);
-    auto maybePath = GetFileFromCache(
+
+    auto maybePath = RequestWithRetry<TMaybe<TYPath>>(
         retryPolicy,
-        OperationPreparer_.GetContext(),
-        TTransactionId(),
-        md5Signature,
-        GetCachePath(),
-        TGetFileFromCacheOptions());
+        [this, &md5Signature] (TMutationId /*mutationId*/) {
+            return RawClient_->GetFileFromCache(TTransactionId(), md5Signature, GetCachePath());
+        });
     if (maybePath) {
         YT_LOG_DEBUG(
             "File is already in cache (FileName: %v, FilePath: %v)",
diff --git a/yt/cpp/mapreduce/client/transaction.cpp b/yt/cpp/mapreduce/client/transaction.cpp
index caf13194682..80230b899dd 100644
--- a/yt/cpp/mapreduce/client/transaction.cpp
+++ b/yt/cpp/mapreduce/client/transaction.cpp
@@ -41,14 +41,13 @@ TPingableTransaction::TPingableTransaction(
     , AutoPingable_(options.AutoPingable_)
     , Pinger_(std::move(transactionPinger))
 {
-    auto transactionId = NDetail::NRawClient::StartTransaction(
+    auto transactionId = NDetail::RequestWithRetry<TTransactionId>(
         ClientRetryPolicy_->CreatePolicyForGenericRequest(),
-        context,
-        parentId,
-        options);
-
+        [this, &parentId, &options] (TMutationId& mutationId) {
+            return RawClient_->StartTransaction(mutationId, parentId, options);
+        });
     auto actualTimeout = options.Timeout_.GetOrElse(Context_.Config->TxTimeout);
-    Init(context, transactionId, actualTimeout);
+    Init(rawClient, context, transactionId, actualTimeout);
 }
 
 TPingableTransaction::TPingableTransaction(
@@ -78,10 +77,11 @@ TPingableTransaction::TPingableTransaction(
         throw yexception() << "Transaction " << GetGuidAsString(transactionId) << " does not exist";
     }
     auto timeout = TDuration::MilliSeconds(timeoutNode.AsInt64());
-    Init(context, transactionId, timeout);
+    Init(rawClient, context, transactionId, timeout);
 }
 
 void TPingableTransaction::Init(
+    const IRawClientPtr& rawClient,
     const TClientContext& context,
     const TTransactionId& transactionId,
     TDuration timeout)
@@ -91,12 +91,12 @@ void TPingableTransaction::Init(
     if (AbortOnTermination_) {
         AbortableRegistry_->Add(
             TransactionId_,
-            ::MakeIntrusive<NDetail::TTransactionAbortable>(context, TransactionId_));
+            ::MakeIntrusive<NDetail::TTransactionAbortable>(rawClient, context, TransactionId_));
     }
 
     if (AutoPingable_) {
         // Compute 'MaxPingInterval_' and 'MinPingInterval_' such that 'pingInterval == (max + min) / 2'.
-        auto pingInterval = Context_.Config->PingInterval;
+        auto pingInterval = context.Config->PingInterval;
         auto safeTimeout = timeout - TDuration::Seconds(5);
         MaxPingInterval_ = Max(pingInterval, Min(safeTimeout, pingInterval * 1.5));
         MinPingInterval_ = pingInterval - (MaxPingInterval_ - pingInterval);
@@ -130,7 +130,7 @@ const TClientContext TPingableTransaction::GetContext() const
 
 void TPingableTransaction::Ping() const
 {
-    RawClient_->PingTx(TransactionId_);
+    RawClient_->PingTransaction(TransactionId_);
 }
 
 void TPingableTransaction::Commit()
@@ -163,16 +163,18 @@ void TPingableTransaction::Stop(EStopAction action)
 
     switch (action) {
         case EStopAction::Commit:
-            NDetail::NRawClient::CommitTransaction(
+            NDetail::RequestWithRetry<void>(
                 ClientRetryPolicy_->CreatePolicyForGenericRequest(),
-                Context_,
-                TransactionId_);
+                [this] (TMutationId& mutationId) {
+                    RawClient_->CommitTransaction(mutationId, TransactionId_);
+                });
             break;
         case EStopAction::Abort:
-            NDetail::NRawClient::AbortTransaction(
+        NDetail::RequestWithRetry<void>(
                 ClientRetryPolicy_->CreatePolicyForGenericRequest(),
-                Context_,
-                TransactionId_);
+                [this] (TMutationId& mutationId) {
+                    RawClient_->AbortTransaction(mutationId, TransactionId_);
+                });
             break;
         case EStopAction::Detach:
             // Do nothing.
diff --git a/yt/cpp/mapreduce/client/transaction.h b/yt/cpp/mapreduce/client/transaction.h
index 5e75b74ca60..d1a5109c3f0 100644
--- a/yt/cpp/mapreduce/client/transaction.h
+++ b/yt/cpp/mapreduce/client/transaction.h
@@ -78,6 +78,7 @@ private:
 
 private:
     void Init(
+        const IRawClientPtr& rawClient,
         const TClientContext& context,
         const TTransactionId& transactionId,
         TDuration timeout);
diff --git a/yt/cpp/mapreduce/interface/raw_client.h b/yt/cpp/mapreduce/interface/raw_client.h
index 5a11a9f9603..32055e3d004 100644
--- a/yt/cpp/mapreduce/interface/raw_client.h
+++ b/yt/cpp/mapreduce/interface/raw_client.h
@@ -115,7 +115,20 @@ public:
 
     // Transactions
 
-    virtual void PingTx(const TTransactionId& transactionId) = 0;
+    virtual TTransactionId StartTransaction(
+        TMutationId& mutationId,
+        const TTransactionId& parentId,
+        const TStartTransactionOptions& options = {}) = 0;
+
+    virtual void PingTransaction(const TTransactionId& transactionId) = 0;
+
+    virtual void AbortTransaction(
+        TMutationId& mutationId,
+        const TTransactionId& transactionId) = 0;
+
+    virtual void CommitTransaction(
+        TMutationId& mutationId,
+        const TTransactionId& transactionId) = 0;
 
     // Operations
 
@@ -183,6 +196,21 @@ public:
         const TOperationId& operationId,
         const TGetJobTraceOptions& options = {}) = 0;
 
+    // File cache
+
+    virtual TMaybe<TYPath> GetFileFromCache(
+        const TTransactionId& transactionId,
+        const TString& md5Signature,
+        const TYPath& cachePath,
+        const TGetFileFromCacheOptions& options = {}) = 0;
+
+    virtual TYPath PutFileToCache(
+        const TTransactionId& transactionId,
+        const TYPath& filePath,
+        const TString& md5Signature,
+        const TYPath& cachePath,
+        const TPutFileToCacheOptions& options = {}) = 0;
+
     // Tables
 
     virtual void MountTable(
@@ -232,8 +260,53 @@ public:
         const TString& query,
         const TSelectRowsOptions& options = {}) = 0;
 
+    virtual void AlterTable(
+        TMutationId& mutationId,
+        const TTransactionId& transactionId,
+        const TYPath& path,
+        const TAlterTableOptions& options = {}) = 0;
+
+    virtual void AlterTableReplica(
+        TMutationId& mutationId,
+        const TReplicaId& replicaId,
+        const TAlterTableReplicaOptions& options = {}) = 0;
+
+    virtual void DeleteRows(
+        const TYPath& path,
+        const TNode::TListType& keys,
+        const TDeleteRowsOptions& options = {}) = 0;
+
+    virtual void FreezeTable(
+        const TYPath& path,
+        const TFreezeTableOptions& options = {}) = 0;
+
+    virtual void UnfreezeTable(
+        const TYPath& path,
+        const TUnfreezeTableOptions& options = {}) = 0;
+
     // Misc
 
+    virtual TCheckPermissionResponse CheckPermission(
+        const TString& user,
+        EPermission permission,
+        const TYPath& path,
+        const TCheckPermissionOptions& options = {}) = 0;
+
+    virtual TVector<TTabletInfo> GetTabletInfos(
+        const TYPath& path,
+        const TVector<int>& tabletIndexes,
+        const TGetTabletInfosOptions& options = {}) = 0;
+
+    virtual TVector<TTableColumnarStatistics> GetTableColumnarStatistics(
+        const TTransactionId& transactionId,
+        const TVector<TRichYPath>& paths,
+        const TGetTableColumnarStatisticsOptions& options = {}) = 0;
+
+    virtual TMultiTablePartitions GetTablePartitions(
+        const TTransactionId& transactionId,
+        const TVector<TRichYPath>& paths,
+        const TGetTablePartitionsOptions& options = {}) = 0;
+
     virtual ui64 GenerateTimestamp() = 0;
 
     virtual TAuthorizationInfo WhoAmI() = 0;
diff --git a/yt/cpp/mapreduce/raw_client/raw_client.cpp b/yt/cpp/mapreduce/raw_client/raw_client.cpp
index 20b03a5ad9e..71d8d5fba90 100644
--- a/yt/cpp/mapreduce/raw_client/raw_client.cpp
+++ b/yt/cpp/mapreduce/raw_client/raw_client.cpp
@@ -189,8 +189,8 @@ TNode::TListType THttpRawClient::List(
         updatedPath.pop_back();
     }
     header.MergeParameters(NRawClient::SerializeParamsForList(transactionId, Context_.Config->Prefix, updatedPath, options));
-    auto result = RequestWithoutRetry(Context_, mutationId, header);
-    return NodeFromYsonString(result.Response).AsList();
+    auto responseInfo = RequestWithoutRetry(Context_, mutationId, header);
+    return NodeFromYsonString(responseInfo.Response).AsList();
 }
 
 TNodeId THttpRawClient::Link(
@@ -244,7 +244,18 @@ void THttpRawClient::Concatenate(
     RequestWithoutRetry(Context_, mutationId, header);
 }
 
-void THttpRawClient::PingTx(const TTransactionId& transactionId)
+TTransactionId THttpRawClient::StartTransaction(
+    TMutationId& mutationId,
+    const TTransactionId& parentTransactionId,
+    const TStartTransactionOptions& options)
+{
+    THttpHeader header("POST", "start_tx");
+    header.AddMutationId();
+    header.MergeParameters(NRawClient::SerializeParamsForStartTransaction(parentTransactionId, Context_.Config->TxTimeout, options));
+    return ParseGuidFromResponse(RequestWithoutRetry(Context_, mutationId, header).Response);
+}
+
+void THttpRawClient::PingTransaction(const TTransactionId& transactionId)
 {
     TMutationId mutationId;
     THttpHeader header("POST", "ping_tx");
@@ -256,6 +267,26 @@ void THttpRawClient::PingTx(const TTransactionId& transactionId)
     RequestWithoutRetry(Context_, mutationId, header);
 }
 
+void THttpRawClient::AbortTransaction(
+    TMutationId& mutationId,
+    const TTransactionId& transactionId)
+{
+    THttpHeader header("POST", "abort_tx");
+    header.AddMutationId();
+    header.MergeParameters(NRawClient::SerializeParamsForAbortTransaction(transactionId));
+    RequestWithoutRetry(Context_, mutationId, header);
+}
+
+void THttpRawClient::CommitTransaction(
+    TMutationId& mutationId,
+    const TTransactionId& transactionId)
+{
+    THttpHeader header("POST", "commit_tx");
+    header.AddMutationId();
+    header.MergeParameters(NRawClient::SerializeParamsForCommitTransaction(transactionId));
+    RequestWithoutRetry(Context_, mutationId, header);
+}
+
 TOperationAttributes THttpRawClient::GetOperation(
     const TOperationId& operationId,
     const TGetOperationOptions& options)
@@ -263,8 +294,8 @@ TOperationAttributes THttpRawClient::GetOperation(
     TMutationId mutationId;
     THttpHeader header("GET", "get_operation");
     header.MergeParameters(NRawClient::SerializeParamsForGetOperation(operationId, options));
-    auto result = RequestWithoutRetry(Context_, mutationId, header);
-    return NRawClient::ParseOperationAttributes(NodeFromYsonString(result.Response));
+    auto responseInfo = RequestWithoutRetry(Context_, mutationId, header);
+    return NRawClient::ParseOperationAttributes(NodeFromYsonString(responseInfo.Response));
 }
 
 TOperationAttributes THttpRawClient::GetOperation(
@@ -274,8 +305,8 @@ TOperationAttributes THttpRawClient::GetOperation(
     TMutationId mutationId;
     THttpHeader header("GET", "get_operation");
     header.MergeParameters(NRawClient::SerializeParamsForGetOperation(alias, options));
-    auto result = RequestWithoutRetry(Context_, mutationId, header);
-    return NRawClient::ParseOperationAttributes(NodeFromYsonString(result.Response));
+    auto responseInfo = RequestWithoutRetry(Context_, mutationId, header);
+    return NRawClient::ParseOperationAttributes(NodeFromYsonString(responseInfo.Response));
 }
 
 void THttpRawClient::AbortOperation(
@@ -555,6 +586,34 @@ std::vector<TJobTraceEvent> THttpRawClient::GetJobTrace(
     return result;
 }
 
+TMaybe<TYPath> THttpRawClient::GetFileFromCache(
+    const TTransactionId& transactionId,
+    const TString& md5Signature,
+    const TYPath& cachePath,
+    const TGetFileFromCacheOptions& options)
+{
+    TMutationId mutationId;
+    THttpHeader header("GET", "get_file_from_cache");
+    header.MergeParameters(NRawClient::SerializeParamsForGetFileFromCache(transactionId, md5Signature, cachePath, options));
+    auto responseInfo = RequestWithoutRetry(Context_, mutationId, header);
+    auto resultNode = NodeFromYsonString(responseInfo.Response).AsString();
+    return resultNode.empty() ? Nothing() : TMaybe<TYPath>(resultNode);
+}
+
+TYPath THttpRawClient::PutFileToCache(
+    const TTransactionId& transactionId,
+    const TYPath& filePath,
+    const TString& md5Signature,
+    const TYPath& cachePath,
+    const TPutFileToCacheOptions& options)
+{
+    TMutationId mutationId;
+    THttpHeader header("POST", "put_file_to_cache");
+    header.MergeParameters(NRawClient::SerializeParamsForPutFileToCache(transactionId, Context_.Config->Prefix, filePath, md5Signature, cachePath, options));
+    auto responseInfo = RequestWithoutRetry(Context_, mutationId, header);
+    return NodeFromYsonString(responseInfo.Response).AsString();
+}
+
 void THttpRawClient::MountTable(
     TMutationId& mutationId,
     const TYPath& path,
@@ -713,6 +772,124 @@ TNode::TListType THttpRawClient::SelectRows(
     return NodeFromYsonString(responseInfo.Response, ::NYson::EYsonType::ListFragment).AsList();
 }
 
+void THttpRawClient::AlterTable(
+    TMutationId& mutationId,
+    const TTransactionId& transactionId,
+    const TYPath& path,
+    const TAlterTableOptions& options)
+{
+    THttpHeader header("POST", "alter_table");
+    header.AddMutationId();
+    header.MergeParameters(NRawClient::SerializeParamsForAlterTable(transactionId, Context_.Config->Prefix, path, options));
+    RequestWithoutRetry(Context_, mutationId, header);
+}
+
+void THttpRawClient::AlterTableReplica(
+    TMutationId& mutationId,
+    const TReplicaId& replicaId,
+    const TAlterTableReplicaOptions& options)
+{
+    THttpHeader header("POST", "alter_table_replica");
+    header.AddMutationId();
+    header.MergeParameters(NRawClient::SerializeParamsForAlterTableReplica(replicaId, options));
+    RequestWithoutRetry(Context_, mutationId, header);
+}
+
+void THttpRawClient::DeleteRows(
+    const TYPath& path,
+    const TNode::TListType& keys,
+    const TDeleteRowsOptions& options)
+{
+    TMutationId mutationId;
+    THttpHeader header("PUT", "delete_rows");
+    header.SetInputFormat(TFormat::YsonBinary());
+    header.MergeParameters(NRawClient::SerializeParametersForDeleteRows(Context_.Config->Prefix, path, options));
+
+    auto body = NodeListToYsonString(keys);
+    TRequestConfig config;
+    config.IsHeavy = true;
+    RequestWithoutRetry(Context_, mutationId, header, body, config);
+}
+
+void THttpRawClient::FreezeTable(
+    const TYPath& path,
+    const TFreezeTableOptions& options)
+{
+    TMutationId mutationId;
+    THttpHeader header("POST", "freeze_table");
+    header.MergeParameters(NRawClient::SerializeParamsForFreezeTable(Context_.Config->Prefix, path, options));
+    RequestWithoutRetry(Context_, mutationId, header);
+}
+
+void THttpRawClient::UnfreezeTable(
+    const TYPath& path,
+    const TUnfreezeTableOptions& options)
+{
+    TMutationId mutationId;
+    THttpHeader header("POST", "unfreeze_table");
+    header.MergeParameters(NRawClient::SerializeParamsForUnfreezeTable(Context_.Config->Prefix, path, options));
+    RequestWithoutRetry(Context_, mutationId, header);
+}
+
+TCheckPermissionResponse THttpRawClient::CheckPermission(
+    const TString& user,
+    EPermission permission,
+    const TYPath& path,
+    const TCheckPermissionOptions& options)
+{
+    TMutationId mutationId;
+    THttpHeader header("GET", "check_permission");
+    header.MergeParameters(NRawClient::SerializeParamsForCheckPermission(user, permission, Context_.Config->Prefix, path, options));
+    auto responseInfo = RequestWithoutRetry(Context_, mutationId, header);
+    return NRawClient::ParseCheckPermissionResponse(NodeFromYsonString(responseInfo.Response));
+}
+
+TVector<TTabletInfo> THttpRawClient::GetTabletInfos(
+    const TYPath& path,
+    const TVector<int>& tabletIndexes,
+    const TGetTabletInfosOptions& options)
+{
+    TMutationId mutationId;
+    THttpHeader header("POST", "api/v4/get_tablet_infos", /*isApi*/ false);
+    header.MergeParameters(NRawClient::SerializeParamsForGetTabletInfos(Context_.Config->Prefix, path, tabletIndexes, options));
+    auto responseInfo = RequestWithoutRetry(Context_, mutationId, header);
+    TVector<TTabletInfo> result;
+    Deserialize(result, *NodeFromYsonString(responseInfo.Response).AsMap().FindPtr("tablets"));
+    return result;
+}
+
+TVector<TTableColumnarStatistics> THttpRawClient::GetTableColumnarStatistics(
+    const TTransactionId& transactionId,
+    const TVector<TRichYPath>& paths,
+    const TGetTableColumnarStatisticsOptions& options)
+{
+    TMutationId mutationId;
+    THttpHeader header("GET", "get_table_columnar_statistics");
+    header.MergeParameters(NRawClient::SerializeParamsForGetTableColumnarStatistics(transactionId, paths, options));
+    TRequestConfig config;
+    config.IsHeavy = true;
+    auto responseInfo = RequestWithoutRetry(Context_, mutationId, header, /*body*/ {}, config);
+    TVector<TTableColumnarStatistics> result;
+    Deserialize(result, NodeFromYsonString(responseInfo.Response));
+    return result;
+}
+
+TMultiTablePartitions THttpRawClient::GetTablePartitions(
+    const TTransactionId& transactionId,
+    const TVector<TRichYPath>& paths,
+    const TGetTablePartitionsOptions& options)
+{
+    TMutationId mutationId;
+    THttpHeader header("GET", "partition_tables");
+    header.MergeParameters(NRawClient::SerializeParamsForGetTablePartitions(transactionId, paths, options));
+    TRequestConfig config;
+    config.IsHeavy = true;
+    auto responseInfo = RequestWithoutRetry(Context_, mutationId, header, /*body*/ {}, config);
+    TMultiTablePartitions result;
+    Deserialize(result, NodeFromYsonString(responseInfo.Response));
+    return result;
+}
+
 ui64 THttpRawClient::GenerateTimestamp()
 {
     TMutationId mutationId;
diff --git a/yt/cpp/mapreduce/raw_client/raw_client.h b/yt/cpp/mapreduce/raw_client/raw_client.h
index 55c5cee4c72..08015f024f8 100644
--- a/yt/cpp/mapreduce/raw_client/raw_client.h
+++ b/yt/cpp/mapreduce/raw_client/raw_client.h
@@ -119,7 +119,20 @@ public:
 
     // Transactions
 
-    void PingTx(const TTransactionId& transactionId) override;
+    TTransactionId StartTransaction(
+        TMutationId& mutationId,
+        const TTransactionId& parentId,
+        const TStartTransactionOptions& options = {}) override;
+
+    void PingTransaction(const TTransactionId& transactionId) override;
+
+    void AbortTransaction(
+        TMutationId& mutationId,
+        const TTransactionId& transactionId) override;
+
+    void CommitTransaction(
+        TMutationId& mutationId,
+        const TTransactionId& transactionId) override;
 
     // Operations
 
@@ -189,6 +202,21 @@ public:
         const TOperationId& operationId,
         const TGetJobTraceOptions& options = {}) override;
 
+    // File cache
+
+    TMaybe<TYPath> GetFileFromCache(
+        const TTransactionId& transactionId,
+        const TString& md5Signature,
+        const TYPath& cachePath,
+        const TGetFileFromCacheOptions& options = {}) override;
+
+    TYPath PutFileToCache(
+        const TTransactionId& transactionId,
+        const TYPath& filePath,
+        const TString& md5Signature,
+        const TYPath& cachePath,
+        const TPutFileToCacheOptions& options = {}) override;
+
     // Tables
 
     void MountTable(
@@ -238,8 +266,53 @@ public:
         const TString& query,
         const TSelectRowsOptions& options = {}) override;
 
+    void AlterTable(
+        TMutationId& mutationId,
+        const TTransactionId& transactionId,
+        const TYPath& path,
+        const TAlterTableOptions& options = {}) override;
+
+    void AlterTableReplica(
+        TMutationId& mutationId,
+        const TReplicaId& replicaId,
+        const TAlterTableReplicaOptions& options = {}) override;
+
+    void DeleteRows(
+        const TYPath& path,
+        const TNode::TListType& keys,
+        const TDeleteRowsOptions& options = {}) override;
+
+    void FreezeTable(
+        const TYPath& path,
+        const TFreezeTableOptions& options = {}) override;
+
+    void UnfreezeTable(
+        const TYPath& path,
+        const TUnfreezeTableOptions& options = {}) override;
+
     // Misc
 
+    TCheckPermissionResponse CheckPermission(
+        const TString& user,
+        EPermission permission,
+        const TYPath& path,
+        const TCheckPermissionOptions& options = {}) override;
+
+    TVector<TTabletInfo> GetTabletInfos(
+        const TYPath& path,
+        const TVector<int>& tabletIndexes,
+        const TGetTabletInfosOptions& options = {}) override;
+
+    TVector<TTableColumnarStatistics> GetTableColumnarStatistics(
+        const TTransactionId& transactionId,
+        const TVector<TRichYPath>& paths,
+        const TGetTableColumnarStatisticsOptions& options = {}) override;
+
+    TMultiTablePartitions GetTablePartitions(
+        const TTransactionId& transactionId,
+        const TVector<TRichYPath>& paths,
+        const TGetTablePartitionsOptions& options = {}) override;
+
     ui64 GenerateTimestamp() override;
 
     TAuthorizationInfo WhoAmI() override;
diff --git a/yt/cpp/mapreduce/raw_client/raw_requests.cpp b/yt/cpp/mapreduce/raw_client/raw_requests.cpp
index 31f09339756..a3f10e6c414 100644
--- a/yt/cpp/mapreduce/raw_client/raw_requests.cpp
+++ b/yt/cpp/mapreduce/raw_client/raw_requests.cpp
@@ -269,34 +269,36 @@ TJobAttributes ParseJobAttributes(const TNode& node)
     return result;
 }
 
-TMaybe<TYPath> GetFileFromCache(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId,
-    const TString& md5Signature,
-    const TYPath& cachePath,
-    const TGetFileFromCacheOptions& options)
+TCheckPermissionResponse ParseCheckPermissionResponse(const TNode& node)
 {
-    THttpHeader header("GET", "get_file_from_cache");
-    header.MergeParameters(SerializeParamsForGetFileFromCache(transactionId, md5Signature, cachePath, options));
-    auto responseInfo = RetryRequestWithPolicy(retryPolicy, context, header);
-    auto path = NodeFromYsonString(responseInfo.Response).AsString();
-    return path.empty() ? Nothing() : TMaybe<TYPath>(path);
-}
+    auto parseSingleResult = [] (const TNode::TMapType& node) {
+        TCheckPermissionResult result;
+        result.Action = ::FromString<ESecurityAction>(node.at("action").AsString());
+        if (auto objectId = node.FindPtr("object_id")) {
+            result.ObjectId = GetGuid(objectId->AsString());
+        }
+        if (auto objectName = node.FindPtr("object_name")) {
+            result.ObjectName = objectName->AsString();
+        }
+        if (auto subjectId = node.FindPtr("subject_id")) {
+            result.SubjectId = GetGuid(subjectId->AsString());
+        }
+        if (auto subjectName = node.FindPtr("subject_name")) {
+            result.SubjectName = subjectName->AsString();
+        }
+        return result;
+    };
 
-TYPath PutFileToCache(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId,
-    const TYPath& filePath,
-    const TString& md5Signature,
-    const TYPath& cachePath,
-    const TPutFileToCacheOptions& options)
-{
-    THttpHeader header("POST", "put_file_to_cache");
-    header.MergeParameters(SerializeParamsForPutFileToCache(transactionId, context.Config->Prefix, filePath, md5Signature, cachePath, options));
-    auto result = RetryRequestWithPolicy(retryPolicy, context, header);
-    return NodeFromYsonString(result.Response).AsString();
+    const auto& mapNode = node.AsMap();
+    TCheckPermissionResponse result;
+    static_cast<TCheckPermissionResult&>(result) = parseSingleResult(mapNode);
+    if (auto columns = mapNode.FindPtr("columns")) {
+        result.Columns.reserve(columns->AsList().size());
+        for (const auto& columnNode : columns->AsList()) {
+            result.Columns.push_back(parseSingleResult(columnNode.AsMap()));
+        }
+    }
+    return result;
 }
 
 TNode::TListType SkyShareTable(
@@ -320,7 +322,7 @@ TNode::TListType SkyShareTable(
         patchedOptions.Pool(context.Config->Pool);
     }
 
-    header.MergeParameters(SerializeParamsForSkyShareTable(proxyName, context.Config->Prefix, tablePaths, patchedOptions));
+    header.MergeParameters(NRawClient::SerializeParamsForSkyShareTable(proxyName, context.Config->Prefix, tablePaths, patchedOptions));
     TClientContext skyApiHost({ .ServerName = host, .HttpClient = NHttpClient::CreateDefaultHttpClient() });
     TResponseInfo response = {};
 
@@ -343,103 +345,6 @@ TNode::TListType SkyShareTable(
     }
 }
 
-TCheckPermissionResponse ParseCheckPermissionResponse(const TNode& node)
-{
-    auto parseSingleResult = [] (const TNode::TMapType& node) {
-        TCheckPermissionResult result;
-        result.Action = ::FromString<ESecurityAction>(node.at("action").AsString());
-        if (auto objectId = node.FindPtr("object_id")) {
-            result.ObjectId = GetGuid(objectId->AsString());
-        }
-        if (auto objectName = node.FindPtr("object_name")) {
-            result.ObjectName = objectName->AsString();
-        }
-        if (auto subjectId = node.FindPtr("subject_id")) {
-            result.SubjectId = GetGuid(subjectId->AsString());
-        }
-        if (auto subjectName = node.FindPtr("subject_name")) {
-            result.SubjectName = subjectName->AsString();
-        }
-        return result;
-    };
-
-    const auto& mapNode = node.AsMap();
-    TCheckPermissionResponse result;
-    static_cast<TCheckPermissionResult&>(result) = parseSingleResult(mapNode);
-    if (auto columns = mapNode.FindPtr("columns")) {
-        result.Columns.reserve(columns->AsList().size());
-        for (const auto& columnNode : columns->AsList()) {
-            result.Columns.push_back(parseSingleResult(columnNode.AsMap()));
-        }
-    }
-    return result;
-}
-
-TCheckPermissionResponse CheckPermission(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TString& user,
-    EPermission permission,
-    const TYPath& path,
-    const TCheckPermissionOptions& options)
-{
-    THttpHeader header("GET", "check_permission");
-    header.MergeParameters(SerializeParamsForCheckPermission(user, permission, context.Config->Prefix, path, options));
-    auto response = RetryRequestWithPolicy(retryPolicy, context, header);
-    return ParseCheckPermissionResponse(NodeFromYsonString(response.Response));
-}
-
-TVector<TTabletInfo> GetTabletInfos(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TYPath& path,
-    const TVector<int>& tabletIndexes,
-    const TGetTabletInfosOptions& options)
-{
-    THttpHeader header("POST", "api/v4/get_tablet_infos", false);
-    header.MergeParameters(SerializeParamsForGetTabletInfos(context.Config->Prefix, path, tabletIndexes, options));
-    auto response = RetryRequestWithPolicy(retryPolicy, context, header);
-    TVector<TTabletInfo> result;
-    Deserialize(result, *NodeFromYsonString(response.Response).AsMap().FindPtr("tablets"));
-    return result;
-}
-
-TVector<TTableColumnarStatistics> GetTableColumnarStatistics(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId,
-    const TVector<TRichYPath>& paths,
-    const TGetTableColumnarStatisticsOptions& options)
-{
-    THttpHeader header("GET", "get_table_columnar_statistics");
-    header.MergeParameters(SerializeParamsForGetTableColumnarStatistics(transactionId, paths, options));
-    TRequestConfig config;
-    config.IsHeavy = true;
-    auto requestResult = RetryRequestWithPolicy(retryPolicy, context, header, {}, config);
-    auto response = NodeFromYsonString(requestResult.Response);
-    TVector<TTableColumnarStatistics> result;
-    Deserialize(result, response);
-    return result;
-}
-
-TMultiTablePartitions GetTablePartitions(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId,
-    const TVector<TRichYPath>& paths,
-    const TGetTablePartitionsOptions& options)
-{
-    THttpHeader header("GET", "partition_tables");
-    header.MergeParameters(SerializeParamsForGetTablePartitions(transactionId, paths, options));
-    TRequestConfig config;
-    config.IsHeavy = true;
-    auto requestResult = RetryRequestWithPolicy(retryPolicy, context, header, {}, config);
-    auto response = NodeFromYsonString(requestResult.Response);
-    TMultiTablePartitions result;
-    Deserialize(result, response);
-    return result;
-}
-
 TRichYPath CanonizeYPath(
     const IRequestRetryPolicyPtr& retryPolicy,
     const TClientContext& context,
@@ -468,104 +373,6 @@ TVector<TRichYPath> CanonizeYPaths(
     return result;
 }
 
-void AlterTable(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId,
-    const TYPath& path,
-    const TAlterTableOptions& options)
-{
-    THttpHeader header("POST", "alter_table");
-    header.AddMutationId();
-    header.MergeParameters(SerializeParamsForAlterTable(transactionId, context.Config->Prefix, path, options));
-    RetryRequestWithPolicy(retryPolicy, context, header);
-}
-
-void AlterTableReplica(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TReplicaId& replicaId,
-    const TAlterTableReplicaOptions& options)
-{
-    THttpHeader header("POST", "alter_table_replica");
-    header.AddMutationId();
-    header.MergeParameters(NRawClient::SerializeParamsForAlterTableReplica(replicaId, options));
-    RetryRequestWithPolicy(retryPolicy, context, header);
-}
-
-void DeleteRows(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TYPath& path,
-    const TNode::TListType& keys,
-    const TDeleteRowsOptions& options)
-{
-    THttpHeader header("PUT", "delete_rows");
-    header.SetInputFormat(TFormat::YsonBinary());
-    header.MergeParameters(NRawClient::SerializeParametersForDeleteRows(context.Config->Prefix, path, options));
-
-    auto body = NodeListToYsonString(keys);
-    TRequestConfig requestConfig;
-    requestConfig.IsHeavy = true;
-    RetryRequestWithPolicy(retryPolicy, context, header, body, requestConfig);
-}
-
-void FreezeTable(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TYPath& path,
-    const TFreezeTableOptions& options)
-{
-    THttpHeader header("POST", "freeze_table");
-    header.MergeParameters(SerializeParamsForFreezeTable(context.Config->Prefix, path, options));
-    RetryRequestWithPolicy(retryPolicy, context, header);
-}
-
-void UnfreezeTable(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TYPath& path,
-    const TUnfreezeTableOptions& options)
-{
-    THttpHeader header("POST", "unfreeze_table");
-    header.MergeParameters(SerializeParamsForUnfreezeTable(context.Config->Prefix, path, options));
-    RetryRequestWithPolicy(retryPolicy, context, header);
-}
-
-void AbortTransaction(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId)
-{
-    THttpHeader header("POST", "abort_tx");
-    header.AddMutationId();
-    header.MergeParameters(NRawClient::SerializeParamsForAbortTransaction(transactionId));
-    RetryRequestWithPolicy(retryPolicy, context, header);
-}
-
-void CommitTransaction(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId)
-{
-    THttpHeader header("POST", "commit_tx");
-    header.AddMutationId();
-    header.MergeParameters(NRawClient::SerializeParamsForCommitTransaction(transactionId));
-    RetryRequestWithPolicy(retryPolicy, context, header);
-}
-
-TTransactionId StartTransaction(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& parentTransactionId,
-    const TStartTransactionOptions& options)
-{
-    THttpHeader header("POST", "start_tx");
-    header.AddMutationId();
-    header.MergeParameters(NRawClient::SerializeParamsForStartTransaction(parentTransactionId, context.Config->TxTimeout, options));
-    return ParseGuidFromResponse(RetryRequestWithPolicy(retryPolicy, context, header).Response);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT::NDetail::NRawClient
diff --git a/yt/cpp/mapreduce/raw_client/raw_requests.h b/yt/cpp/mapreduce/raw_client/raw_requests.h
index 494f145fae4..c60536c86d0 100644
--- a/yt/cpp/mapreduce/raw_client/raw_requests.h
+++ b/yt/cpp/mapreduce/raw_client/raw_requests.h
@@ -35,71 +35,17 @@ void ExecuteBatch(
     IRequestRetryPolicyPtr retryPolicy,
     const TClientContext& context,
     TRawBatchRequest& batchRequest,
-    const TExecuteBatchOptions& options = TExecuteBatchOptions());
+    const TExecuteBatchOptions& options = {});
 
-//
-// File cache
-//
-
-TMaybe<TYPath> GetFileFromCache(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId,
-    const TString& md5Signature,
-    const TYPath& cachePath,
-    const TGetFileFromCacheOptions& options = TGetFileFromCacheOptions());
-
-TYPath PutFileToCache(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId,
-    const TYPath& filePath,
-    const TString& md5Signature,
-    const TYPath& cachePath,
-    const TPutFileToCacheOptions& options = TPutFileToCacheOptions());
-
-//
 // SkyShare
-//
 
 TNode::TListType SkyShareTable(
     const IRequestRetryPolicyPtr& retryPolicy,
     const TClientContext& context,
     const std::vector<TYPath>& tablePaths,
-    const TSkyShareTableOptions& options);
+    const TSkyShareTableOptions& options = {});
 
-//
 // Misc
-//
-
-TCheckPermissionResponse CheckPermission(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TString& user,
-    EPermission permission,
-    const TYPath& path,
-    const TCheckPermissionOptions& options = TCheckPermissionOptions());
-
-TVector<TTabletInfo> GetTabletInfos(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TYPath& path,
-    const TVector<int>& tabletIndexes,
-    const TGetTabletInfosOptions& options);
-
-TVector<TTableColumnarStatistics> GetTableColumnarStatistics(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId,
-    const TVector<TRichYPath>& paths,
-    const TGetTableColumnarStatisticsOptions& options);
-
-TMultiTablePartitions GetTablePartitions(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId,
-    const TVector<TRichYPath>& paths,
-    const TGetTablePartitionsOptions& options);
 
 TRichYPath CanonizeYPath(
     const IRequestRetryPolicyPtr& retryPolicy,
@@ -111,60 +57,6 @@ TVector<TRichYPath> CanonizeYPaths(
     const TClientContext& context,
     const TVector<TRichYPath>& paths);
 
-//
-// Tables
-//
-
-void AlterTable(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId,
-    const TYPath& path,
-    const TAlterTableOptions& options);
-
-void AlterTableReplica(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TReplicaId& replicaId,
-    const TAlterTableReplicaOptions& options);
-
-void DeleteRows(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TYPath& path,
-    const TNode::TListType& keys,
-    const TDeleteRowsOptions& options);
-
-void FreezeTable(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TYPath& path,
-    const TFreezeTableOptions& options);
-
-void UnfreezeTable(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TYPath& path,
-    const TUnfreezeTableOptions& options);
-
-
-// Transactions
-void AbortTransaction(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId);
-
-void CommitTransaction(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& transactionId);
-
-TTransactionId StartTransaction(
-    const IRequestRetryPolicyPtr& retryPolicy,
-    const TClientContext& context,
-    const TTransactionId& parentId,
-    const TStartTransactionOptions& options);
-
 ////////////////////////////////////////////////////////////////////////////////
 
 template<typename TSrc, typename TBatchAdder>