modifications refactoring

37 files changed, 643 insertions, 174 deletions

diff --git a/ydb/core/kqp/gateway/kqp_ic_gateway.cpp b/ydb/core/kqp/gateway/kqp_ic_gateway.cpp
index 64a0717ce6c..72bc0fb3146 100644
--- a/ydb/core/kqp/gateway/kqp_ic_gateway.cpp
+++ b/ydb/core/kqp/gateway/kqp_ic_gateway.cpp
@@ -1515,7 +1515,7 @@ public:
     protected:
         virtual TFuture<NMetadata::NModifications::TObjectOperatorResult> DoExecute(
             NMetadata::IClassBehaviour::TPtr manager, const TSettings& settings,
-            const NMetadata::NModifications::IOperationsManager::TModificationContext& context) = 0;
+            const NMetadata::NModifications::IOperationsManager::TExternalModificationContext& context) = 0;
         ui32 GetNodeId() const {
             return Owner.NodeId;
         }
@@ -1544,7 +1544,7 @@ public:
                 if (!cBehaviour->GetOperationsManager()) {
                     return MakeFuture(ResultFromError<TGenericResult>("type has not manager for operations"));
                 }
-                NMetadata::NModifications::IOperationsManager::TModificationContext context;
+                NMetadata::NModifications::IOperationsManager::TExternalModificationContext context;
                 if (GetUserToken()) {
                     context.SetUserToken(*GetUserToken());
                 }
@@ -1571,7 +1571,7 @@ public:
     protected:
         virtual TFuture<NMetadata::NModifications::TObjectOperatorResult> DoExecute(
             NMetadata::IClassBehaviour::TPtr manager, const NYql::TCreateObjectSettings& settings,
-            const NMetadata::NModifications::IOperationsManager::TModificationContext& context) override
+            const NMetadata::NModifications::IOperationsManager::TExternalModificationContext& context) override
         {
             return manager->GetOperationsManager()->CreateObject(settings, TBase::GetNodeId(), manager, context);
         }
@@ -1585,7 +1585,7 @@ public:
     protected:
         virtual TFuture<NMetadata::NModifications::TObjectOperatorResult> DoExecute(
             NMetadata::IClassBehaviour::TPtr manager, const NYql::TAlterObjectSettings& settings,
-            const NMetadata::NModifications::IOperationsManager::TModificationContext& context) override {
+            const NMetadata::NModifications::IOperationsManager::TExternalModificationContext& context) override {
             return manager->GetOperationsManager()->AlterObject(settings, TBase::GetNodeId(), manager, context);
         }
     public:
@@ -1598,7 +1598,7 @@ public:
     protected:
         virtual TFuture<NMetadata::NModifications::TObjectOperatorResult> DoExecute(
             NMetadata::IClassBehaviour::TPtr manager, const NYql::TDropObjectSettings& settings,
-            const NMetadata::NModifications::IOperationsManager::TModificationContext& context) override {
+            const NMetadata::NModifications::IOperationsManager::TExternalModificationContext& context) override {
             return manager->GetOperationsManager()->DropObject(settings, TBase::GetNodeId(), manager, context);
         }
     public:
diff --git a/ydb/core/tx/tiering/rule/checker.cpp b/ydb/core/tx/tiering/rule/checker.cpp
index 5c7c2efb72a..3905461389e 100644
--- a/ydb/core/tx/tiering/rule/checker.cpp
+++ b/ydb/core/tx/tiering/rule/checker.cpp
@@ -26,10 +26,10 @@ void TRulePreparationActor::StartChecker() {
             if (!tier) {
                 Controller->OnPreparationProblem("unknown tier usage: " + interval.GetTierName());
                 return;
-            } else if (!Secrets->CheckSecretAccess(tier->GetAccessKey(), Context.GetUserToken())) {
+            } else if (!Secrets->CheckSecretAccess(tier->GetAccessKey(), Context.GetExternalData().GetUserToken())) {
                 Controller->OnPreparationProblem("no access for secret: " + tier->GetAccessKey().DebugString());
                 return;
-            } else if (!Secrets->CheckSecretAccess(tier->GetSecretKey(), Context.GetUserToken())) {
+            } else if (!Secrets->CheckSecretAccess(tier->GetSecretKey(), Context.GetExternalData().GetUserToken())) {
                 Controller->OnPreparationProblem("no access for secret: " + tier->GetSecretKey().DebugString());
                 return;
             }
@@ -75,7 +75,7 @@ void TRulePreparationActor::Bootstrap() {
         new NMetadata::NProvider::TEvAskSnapshot(std::make_shared<NMetadata::NSecret::TSnapshotsFetcher>()));
     {
         SSFetcher = std::make_shared<TFetcherCheckUserTieringPermissions>();
-        SSFetcher->SetUserToken(Context.GetUserToken());
+        SSFetcher->SetUserToken(Context.GetExternalData().GetUserToken());
         SSFetcher->SetActivityType(Context.GetActivityType());
         for (auto&& i : Objects) {
             SSFetcher->MutableTieringRuleIds().emplace(i.GetTieringRuleId());
@@ -86,7 +86,7 @@ void TRulePreparationActor::Bootstrap() {
 
 TRulePreparationActor::TRulePreparationActor(std::vector<TTieringRule>&& objects,
     NMetadata::NModifications::IAlterPreparationController<TTieringRule>::TPtr controller,
-    const NMetadata::NModifications::IOperationsManager::TModificationContext& context)
+    const NMetadata::NModifications::IOperationsManager::TInternalModificationContext& context)
     : Objects(std::move(objects))
     , Controller(controller)
     , Context(context)
diff --git a/ydb/core/tx/tiering/rule/checker.h b/ydb/core/tx/tiering/rule/checker.h
index 98e55f85446..ec6e0f3d66e 100644
--- a/ydb/core/tx/tiering/rule/checker.h
+++ b/ydb/core/tx/tiering/rule/checker.h
@@ -16,7 +16,7 @@ class TRulePreparationActor: public NActors::TActorBootstrapped<TRulePreparation
 private:
     std::vector<TTieringRule> Objects;
     NMetadata::NModifications::IAlterPreparationController<TTieringRule>::TPtr Controller;
-    NMetadata::NModifications::IOperationsManager::TModificationContext Context;
+    NMetadata::NModifications::IOperationsManager::TInternalModificationContext Context;
     std::shared_ptr<TConfigsSnapshot> Tierings;
     std::shared_ptr<NMetadata::NSecret::TSnapshot> Secrets;
     std::shared_ptr<TFetcherCheckUserTieringPermissions> SSFetcher;
@@ -38,7 +38,7 @@ public:
 
     TRulePreparationActor(std::vector<TTieringRule>&& objects,
         NMetadata::NModifications::IAlterPreparationController<TTieringRule>::TPtr controller,
-        const NMetadata::NModifications::IOperationsManager::TModificationContext& context);
+        const NMetadata::NModifications::IOperationsManager::TInternalModificationContext& context);
 };
 
 }
diff --git a/ydb/core/tx/tiering/rule/manager.cpp b/ydb/core/tx/tiering/rule/manager.cpp
index 7fd2a201ec3..b3f53c7ba18 100644
--- a/ydb/core/tx/tiering/rule/manager.cpp
+++ b/ydb/core/tx/tiering/rule/manager.cpp
@@ -6,13 +6,13 @@ namespace NKikimr::NColumnShard::NTiers {
 
 void TTieringRulesManager::DoPrepareObjectsBeforeModification(std::vector<TTieringRule>&& objects,
     NMetadata::NModifications::IAlterPreparationController<TTieringRule>::TPtr controller,
-    const NMetadata::NModifications::IOperationsManager::TModificationContext& context) const {
+    const TInternalModificationContext& context) const {
     TActivationContext::Register(new TRulePreparationActor(std::move(objects), controller, context));
 }
 
 NMetadata::NModifications::TOperationParsingResult TTieringRulesManager::DoBuildPatchFromSettings(
     const NYql::TObjectSettingsImpl& settings,
-    const NMetadata::NModifications::IOperationsManager::TModificationContext& /*context*/) const {
+    TInternalModificationContext& /*context*/) const {
     NMetadata::NInternal::TTableRecord result;
     result.SetColumn(TTieringRule::TDecoder::TieringRuleId, NMetadata::NInternal::TYDBValue::Utf8(settings.GetObjectId()));
     {
diff --git a/ydb/core/tx/tiering/rule/manager.h b/ydb/core/tx/tiering/rule/manager.h
index 371e931ef04..3268c90021c 100644
--- a/ydb/core/tx/tiering/rule/manager.h
+++ b/ydb/core/tx/tiering/rule/manager.h
@@ -9,10 +9,10 @@ class TTieringRulesManager: public NMetadata::NModifications::TGenericOperations
 protected:
     virtual void DoPrepareObjectsBeforeModification(std::vector<TTieringRule>&& objects,
         NMetadata::NModifications::IAlterPreparationController<TTieringRule>::TPtr controller,
-        const NMetadata::NModifications::IOperationsManager::TModificationContext& context) const override;
+        const TInternalModificationContext& context) const override;
 
     virtual NMetadata::NModifications::TOperationParsingResult DoBuildPatchFromSettings(const NYql::TObjectSettingsImpl& settings,
-        const NMetadata::NModifications::IOperationsManager::TModificationContext& /*context*/) const override;
+        TInternalModificationContext& context) const override;
 };
 
 }
diff --git a/ydb/core/tx/tiering/tier/checker.cpp b/ydb/core/tx/tiering/tier/checker.cpp
index e6fd1193516..9cb2f458055 100644
--- a/ydb/core/tx/tiering/tier/checker.cpp
+++ b/ydb/core/tx/tiering/tier/checker.cpp
@@ -31,10 +31,10 @@ void TTierPreparationActor::StartChecker() {
                 return;
             }
         }
-        if (!Secrets->CheckSecretAccess(tier.GetAccessKey(), Context.GetUserToken())) {
+        if (!Secrets->CheckSecretAccess(tier.GetAccessKey(), Context.GetExternalData().GetUserToken())) {
             Controller->OnPreparationProblem("no access for secret: " + tier.GetAccessKey().DebugString());
             return;
-        } else if (!Secrets->CheckSecretAccess(tier.GetSecretKey(), Context.GetUserToken())) {
+        } else if (!Secrets->CheckSecretAccess(tier.GetSecretKey(), Context.GetExternalData().GetUserToken())) {
             Controller->OnPreparationProblem("no access for secret: " + tier.GetSecretKey().DebugString());
             return;
         }
@@ -80,7 +80,7 @@ void TTierPreparationActor::Handle(NMetadata::NProvider::TEvRefreshSubscriberDat
         }
         {
             SSFetcher = std::make_shared<TFetcherCheckUserTieringPermissions>();
-            SSFetcher->SetUserToken(Context.GetUserToken());
+            SSFetcher->SetUserToken(Context.GetExternalData().GetUserToken());
             SSFetcher->SetActivityType(Context.GetActivityType());
             SSFetcher->MutableTieringRuleIds() = tieringIds;
             Register(new TSSFetchingActor(SSFetcher, std::make_shared<TSSFetchingController>(SelfId()), TDuration::Seconds(10)));
@@ -101,7 +101,7 @@ void TTierPreparationActor::Bootstrap() {
 
 TTierPreparationActor::TTierPreparationActor(std::vector<TTierConfig>&& objects,
     NMetadata::NModifications::IAlterPreparationController<TTierConfig>::TPtr controller,
-    const NMetadata::NModifications::IOperationsManager::TModificationContext& context)
+    const NMetadata::NModifications::IOperationsManager::TInternalModificationContext& context)
     : Objects(std::move(objects))
     , Controller(controller)
     , Context(context)
diff --git a/ydb/core/tx/tiering/tier/checker.h b/ydb/core/tx/tiering/tier/checker.h
index 903e010c9d2..2b1d5ffd2e7 100644
--- a/ydb/core/tx/tiering/tier/checker.h
+++ b/ydb/core/tx/tiering/tier/checker.h
@@ -16,7 +16,7 @@ class TTierPreparationActor: public NActors::TActorBootstrapped<TTierPreparation
 private:
     std::vector<TTierConfig> Objects;
     NMetadata::NModifications::IAlterPreparationController<TTierConfig>::TPtr Controller;
-    NMetadata::NModifications::IOperationsManager::TModificationContext Context;
+    NMetadata::NModifications::IOperationsManager::TInternalModificationContext Context;
     std::shared_ptr<NMetadata::NSecret::TSnapshot> Secrets;
     std::shared_ptr<TConfigsSnapshot> Tierings;
     std::shared_ptr<TFetcherCheckUserTieringPermissions> SSFetcher;
@@ -38,7 +38,7 @@ public:
 
     TTierPreparationActor(std::vector<TTierConfig>&& objects,
         NMetadata::NModifications::IAlterPreparationController<TTierConfig>::TPtr controller,
-        const NMetadata::NModifications::IOperationsManager::TModificationContext& context);
+        const NMetadata::NModifications::IOperationsManager::TInternalModificationContext& context);
 };
 
 }
diff --git a/ydb/core/tx/tiering/tier/manager.cpp b/ydb/core/tx/tiering/tier/manager.cpp
index d36efdf6749..27a47325150 100644
--- a/ydb/core/tx/tiering/tier/manager.cpp
+++ b/ydb/core/tx/tiering/tier/manager.cpp
@@ -6,7 +6,7 @@ namespace NKikimr::NColumnShard::NTiers {
 
 NMetadata::NModifications::TOperationParsingResult TTiersManager::DoBuildPatchFromSettings(
     const NYql::TObjectSettingsImpl& settings,
-    const NMetadata::NModifications::IOperationsManager::TModificationContext& context) const
+    TInternalModificationContext& context) const
 {
     NMetadata::NInternal::TTableRecord result;
     result.SetColumn(TTierConfig::TDecoder::TierName, NMetadata::NInternal::TYDBValue::Utf8(settings.GetObjectId()));
@@ -18,8 +18,8 @@ NMetadata::NModifications::TOperationParsingResult TTiersManager::DoBuildPatchFr
                 return "incorrect proto format";
             } else if (proto.HasObjectStorage()) {
                 TString defaultUserId;
-                if (context.GetUserToken()) {
-                    defaultUserId = context.GetUserToken()->GetUserSID();
+                if (context.GetExternalData().GetUserToken()) {
+                    defaultUserId = context.GetExternalData().GetUserToken()->GetUserSID();
                 }
 
                 if (proto.GetObjectStorage().HasSecretableAccessKey()) {
@@ -62,7 +62,7 @@ NMetadata::NModifications::TOperationParsingResult TTiersManager::DoBuildPatchFr
 
 void TTiersManager::DoPrepareObjectsBeforeModification(std::vector<TTierConfig>&& patchedObjects,
     NMetadata::NModifications::IAlterPreparationController<TTierConfig>::TPtr controller,
-    const NMetadata::NModifications::IOperationsManager::TModificationContext& context) const
+    const TInternalModificationContext& context) const
 {
     TActivationContext::Register(new TTierPreparationActor(std::move(patchedObjects), controller, context));
 }
diff --git a/ydb/core/tx/tiering/tier/manager.h b/ydb/core/tx/tiering/tier/manager.h
index 32f44815673..ba777648139 100644
--- a/ydb/core/tx/tiering/tier/manager.h
+++ b/ydb/core/tx/tiering/tier/manager.h
@@ -9,10 +9,10 @@ class TTiersManager: public NMetadata::NModifications::TGenericOperationsManager
 protected:
     virtual void DoPrepareObjectsBeforeModification(std::vector<TTierConfig>&& patchedObjects,
         NMetadata::NModifications::IAlterPreparationController<TTierConfig>::TPtr controller,
-        const NMetadata::NModifications::IOperationsManager::TModificationContext& context) const override;
+        const TInternalModificationContext& context) const override;
 
     virtual NMetadata::NModifications::TOperationParsingResult DoBuildPatchFromSettings(const NYql::TObjectSettingsImpl& settings,
-        const NMetadata::NModifications::IOperationsManager::TModificationContext& /*context*/) const override;
+        TInternalModificationContext& context) const override;
 public:
 };
 
diff --git a/ydb/services/metadata/abstract/decoder.cpp b/ydb/services/metadata/abstract/decoder.cpp
index f182f1487ec..d08b85bb108 100644
--- a/ydb/services/metadata/abstract/decoder.cpp
+++ b/ydb/services/metadata/abstract/decoder.cpp
@@ -32,6 +32,28 @@ bool TDecoderBase::Read(const i32 columnIdx, TString& result, const Ydb::Value&
     return true;
 }
 
+bool TDecoderBase::Read(const i32 columnIdx, ui64& result, const Ydb::Value& r) const {
+    if (columnIdx >= (i32)r.items().size() || columnIdx < 0) {
+        return false;
+    }
+    if (r.items()[columnIdx].has_uint64_value()) {
+        result = r.items()[columnIdx].uint64_value();
+        return true;
+    }
+    return false;
+}
+
+bool TDecoderBase::Read(const i32 columnIdx, ui32& result, const Ydb::Value& r) const {
+    if (columnIdx >= (i32)r.items().size() || columnIdx < 0) {
+        return false;
+    }
+    if (r.items()[columnIdx].has_uint32_value()) {
+        result = r.items()[columnIdx].uint32_value();
+        return true;
+    }
+    return false;
+}
+
 bool TDecoderBase::Read(const i32 columnIdx, TDuration& result, const Ydb::Value& r) const {
     if (columnIdx >= (i32)r.items().size() || columnIdx < 0) {
         return false;
diff --git a/ydb/services/metadata/abstract/decoder.h b/ydb/services/metadata/abstract/decoder.h
index 465df2aa44d..4f89eb559e4 100644
--- a/ydb/services/metadata/abstract/decoder.h
+++ b/ydb/services/metadata/abstract/decoder.h
@@ -13,8 +13,20 @@ protected:
 
 public:
     bool Read(const i32 columnIdx, TString& result, const Ydb::Value& r) const;
+    bool Read(const i32 columnIdx, ui64& result, const Ydb::Value& r) const;
+    bool Read(const i32 columnIdx, ui32& result, const Ydb::Value& r) const;
     bool ReadDebugProto(const i32 columnIdx, ::google::protobuf::Message& result, const Ydb::Value& r) const;
     bool ReadJson(const i32 columnIdx, NJson::TJsonValue& result, const Ydb::Value& r) const;
+
+    template <class T>
+    bool ReadFromJson(const i32 columnIdx, T& result, const Ydb::Value& r) const {
+        NJson::TJsonValue resultJson;
+        if (!ReadJson(columnIdx, resultJson, r)) {
+            return false;
+        }
+        return result.DeserializeFromJson(resultJson);
+    }
+
     bool Read(const i32 columnIdx, TDuration& result, const Ydb::Value& r) const;
     bool Read(const i32 columnIdx, TInstant& result, const Ydb::Value& r) const;
     bool Read(const i32 columnIdx, bool& result, const Ydb::Value& r) const;
diff --git a/ydb/services/metadata/abstract/kqp_common.cpp b/ydb/services/metadata/abstract/kqp_common.cpp
index bd192a9c7c1..389c370c628 100644
--- a/ydb/services/metadata/abstract/kqp_common.cpp
+++ b/ydb/services/metadata/abstract/kqp_common.cpp
@@ -6,6 +6,10 @@
 
 namespace NKikimr::NMetadata {
 
+TString IClassBehaviour::GetStorageTableDirectory() const {
+    return TFsPath(GetStorageTablePath()).Fix().Parent().GetPath();
+}
+
 TString IClassBehaviour::GetStorageTablePath() const {
     return "/" + AppData()->TenantName + "/" + NMetadata::NProvider::TServiceOperator::GetPath() + "/" + GetInternalStorageTablePath();
 }
diff --git a/ydb/services/metadata/abstract/kqp_common.h b/ydb/services/metadata/abstract/kqp_common.h
index e1ed9140490..277afe0cca1 100644
--- a/ydb/services/metadata/abstract/kqp_common.h
+++ b/ydb/services/metadata/abstract/kqp_common.h
@@ -24,6 +24,7 @@ protected:
 public:
     virtual ~IClassBehaviour() = default;
     TString GetStorageTablePath() const;
+    TString GetStorageTableDirectory() const;
     TString GetStorageHistoryTablePath() const;
     std::shared_ptr<NInitializer::IInitializationBehaviour> GetInitializer() const;
     virtual std::shared_ptr<NModifications::IOperationsManager> GetOperationsManager() const = 0;
diff --git a/ydb/services/metadata/ds_table/behaviour_registrator_actor.cpp b/ydb/services/metadata/ds_table/behaviour_registrator_actor.cpp
index 4f1ef808ebe..39b90ddd15f 100644
--- a/ydb/services/metadata/ds_table/behaviour_registrator_actor.cpp
+++ b/ydb/services/metadata/ds_table/behaviour_registrator_actor.cpp
@@ -17,11 +17,11 @@ public:
     virtual void OnInitializationFinished(const TString& id) const override {
         ActorId.Send(ActorId, new NInitializer::TEvInitializationFinished(id));
     }
-    virtual void OnDescriptionFailed(const TString& errorMessage, const TString& requestId) const override {
+    virtual void OnDescriptionFailed(const TString& errorMessage, const TString& requestId) override {
         ActorId.Send(ActorId, new TEvTableDescriptionFailed(errorMessage, requestId));
     }
-    virtual void OnDescriptionSuccess(THashMap<ui32, TSysTables::TTableColumnInfo>&& result, const TString& requestId) const override {
-        ActorId.Send(ActorId, new TEvTableDescriptionSuccess(std::move(result), requestId));
+    virtual void OnDescriptionSuccess(TTableInfo&& result, const TString& requestId) override {
+        ActorId.Send(ActorId, new TEvTableDescriptionSuccess(std::move(result->Columns), requestId));
     }
 };
 
diff --git a/ydb/services/metadata/ds_table/registration.h b/ydb/services/metadata/ds_table/registration.h
index 307489238ad..f9a12c4a173 100644
--- a/ydb/services/metadata/ds_table/registration.h
+++ b/ydb/services/metadata/ds_table/registration.h
@@ -44,17 +44,18 @@ class TEventsWaiter {
 private:
     std::deque<TWaitEvent> Events;
 public:
-    void Add(TAutoPtr<IEventBase> ev, const TActorId& sender) {
+    bool Add(TAutoPtr<IEventBase> ev, const TActorId& sender) {
         if (Events.size() > 10000) {
             ALS_ERROR(NKikimrServices::METADATA_PROVIDER) << "too many events for deferred sending (maybe service cannot start)";
-            return;
+            return false;
         }
         Events.emplace_back(ev, sender);
+        return true;
     }
 
     template <class T>
-    void Add(TEventHandleFat<T>& ev) {
-        Add(ev.ReleaseBase(), ev.Sender);
+    bool Add(TEventHandleFat<T>& ev) {
+        return Add(ev.ReleaseBase(), ev.Sender);
     }
 
     bool ResendOne(const TActorIdentity& receiver) {
@@ -86,6 +87,53 @@ public:
     }
 };
 
+template <class TTag = TString>
+class TTaggedEventsWaiter {
+private:
+    std::map<TString, TEventsWaiter> TaggedEvents;
+    ui32 EventsCount = 0;
+public:
+    bool Add(TAutoPtr<IEventBase> ev, const TActorId& sender, const TString& tag) {
+        if (EventsCount > 10000) {
+            ALS_ERROR(NKikimrServices::METADATA_PROVIDER) << "too many events for deferred sending (maybe service cannot start)";
+            return false;
+        }
+        TaggedEvents[tag].Add(ev, sender);
+        ++EventsCount;
+        return true;
+    }
+
+    template <class T>
+    bool Add(TEventHandleFat<T>& ev, const TString& tag) {
+        return Add(ev.ReleaseBase(), ev.Sender, tag);
+    }
+
+    bool ResendOne(const TActorIdentity& receiver, const TString& tag) {
+        auto it = TaggedEvents.find(tag);
+        if (it == TaggedEvents.end()) {
+            return false;
+        }
+        if (it->second.ResendOne(receiver)) {
+            --EventsCount;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    void ResendAll(const TActorIdentity& receiver) {
+        for (auto&& i : TaggedEvents) {
+            i.second.ResendAll(receiver);
+        }
+        TaggedEvents.clear();
+        EventsCount = 0;
+    }
+
+    bool IsEmpty() const {
+        return EventsCount == 0;
+    }
+};
+
 class TEventsCollector {
 private:
     const TActorIdentity OwnerId;
diff --git a/ydb/services/metadata/ds_table/scheme_describe.cpp b/ydb/services/metadata/ds_table/scheme_describe.cpp
index 83f824b1ea8..2d518435d55 100644
--- a/ydb/services/metadata/ds_table/scheme_describe.cpp
+++ b/ydb/services/metadata/ds_table/scheme_describe.cpp
@@ -8,40 +8,65 @@
 
 namespace NKikimr::NMetadata::NProvider {
 
-void TSchemeDescriptionActor::Handle(TEvTxProxySchemeCache::TEvNavigateKeySetResult::TPtr& ev) {
+void TSchemeDescriptionActorImpl::Handle(TEvTxProxySchemeCache::TEvNavigateKeySetResult::TPtr& ev) {
     auto* info = ev->Get();
     const auto& request = info->Request;
     auto g = PassAwayGuard();
 
     if (request->ResultSet.empty()) {
-        Controller->OnDescriptionFailed("navigation problems for path " + Path, RequestId);
+        Controller->OnDescriptionFailed("navigation problems for " + DebugString(), RequestId);
         return;
     }
     if (request->ResultSet.size() != 1) {
-        Controller->OnDescriptionFailed("cannot resolve database path " + Path, RequestId);
+        Controller->OnDescriptionFailed("cannot resolve " + DebugString(), RequestId);
         return;
     }
     auto& entity = request->ResultSet.front();
     if (entity.Status == NSchemeCache::TSchemeCacheNavigate::EStatus::Ok) {
-        Controller->OnDescriptionSuccess(std::move(entity.Columns), RequestId);
+        Controller->OnDescriptionSuccess(TTableInfo(std::move(entity)), RequestId);
     } else {
         Controller->OnDescriptionFailed("incorrect path status: " + ::ToString(entity.Status), RequestId);
     }
 }
 
-void TSchemeDescriptionActor::Bootstrap() {
+void TSchemeDescriptionActorImpl::Bootstrap() {
     Become(&TSchemeDescriptionActor::StateMain);
 
     auto request = MakeHolder<NSchemeCache::TSchemeCacheNavigate>();
     request->DatabaseName = NKikimr::CanonizePath(AppData()->TenantName);
     auto& entry = request->ResultSet.emplace_back();
     entry.Operation = NSchemeCache::TSchemeCacheNavigate::OpTable;
-    entry.Path = NKikimr::SplitPath(Path);
+    InitEntry(entry);
     Send(MakeSchemeCacheID(), new TEvTxProxySchemeCache::TEvNavigateKeySet(request.Release()));
 }
 
-NKikimrServices::TActivity::EType TSchemeDescriptionActor::ActorActivityType() {
+NKikimrServices::TActivity::EType TSchemeDescriptionActorImpl::ActorActivityType() {
     return NKikimrServices::TActivity::METADATA_SCHEME_DESCRIPTION_ACTOR;
 }
 
+std::vector<TSysTables::TTableColumnInfo> TTableInfo::GetPKFields() const {
+    std::vector<TString> result;
+    std::vector<TSysTables::TTableColumnInfo> orderedKeys;
+    for (auto&& i : Entry.Columns) {
+        if (i.second.KeyOrder != -1) {
+            orderedKeys.emplace_back(i.second);
+        }
+    }
+    const auto pred = [](const TSysTables::TTableColumnInfo& l, const TSysTables::TTableColumnInfo& r) {
+        return l.KeyOrder < r.KeyOrder;
+    };
+    std::sort(orderedKeys.begin(), orderedKeys.end(), pred);
+    return orderedKeys;
+}
+
+std::vector<TString> TTableInfo::GetPKFieldNames() const {
+    std::vector<TSysTables::TTableColumnInfo> orderedKeys = GetPKFields();
+    std::vector<TString> result;
+    result.reserve(orderedKeys.size());
+    for (auto&& i : orderedKeys) {
+        result.emplace_back(i.Name);
+    }
+    return result;
+}
+
 }
diff --git a/ydb/services/metadata/ds_table/scheme_describe.h b/ydb/services/metadata/ds_table/scheme_describe.h
index 3a57dc4d84d..7f0e776a25d 100644
--- a/ydb/services/metadata/ds_table/scheme_describe.h
+++ b/ydb/services/metadata/ds_table/scheme_describe.h
@@ -5,12 +5,34 @@
 
 namespace NKikimr::NMetadata::NProvider {
 
+class TTableInfo {
+private:
+    NSchemeCache::TSchemeCacheNavigate::TEntry Entry;
+public:
+    TTableInfo(NSchemeCache::TSchemeCacheNavigate::TEntry&& entry)
+        : Entry(std::move(entry))
+    {
+
+    }
+
+    std::vector<TSysTables::TTableColumnInfo> GetPKFields() const;
+    std::vector<TString> GetPKFieldNames() const;
+
+    const NSchemeCache::TSchemeCacheNavigate::TEntry* operator->() const {
+        return &Entry;
+    }
+
+    NSchemeCache::TSchemeCacheNavigate::TEntry* operator->() {
+        return &Entry;
+    }
+};
+
 class ISchemeDescribeController {
 public:
     using TPtr = std::shared_ptr<ISchemeDescribeController>;
     virtual ~ISchemeDescribeController() = default;
-    virtual void OnDescriptionFailed(const TString& errorMessage, const TString& requestId) const = 0;
-    virtual void OnDescriptionSuccess(THashMap<ui32, TSysTables::TTableColumnInfo>&& result, const TString& requestId) const = 0;
+    virtual void OnDescriptionFailed(const TString& errorMessage, const TString& requestId) = 0;
+    virtual void OnDescriptionSuccess(TTableInfo&& result, const TString& requestId) = 0;
 };
 
 class TEvTableDescriptionFailed: public TEventLocal<TEvTableDescriptionFailed, EEvents::EvTableDescriptionFailed> {
@@ -41,13 +63,15 @@ public:
     }
 };
 
-class TSchemeDescriptionActor: public NActors::TActorBootstrapped<TSchemeDescriptionActor> {
+class TSchemeDescriptionActorImpl: public NActors::TActorBootstrapped<TSchemeDescriptionActorImpl> {
 private:
-    using TBase = NActors::TActorBootstrapped<TSchemeDescriptionActor>;
+    using TBase = NActors::TActorBootstrapped<TSchemeDescriptionActorImpl>;
     ISchemeDescribeController::TPtr Controller;
-    TString Path;
     TString RequestId;
     void Handle(TEvTxProxySchemeCache::TEvNavigateKeySetResult::TPtr& ev);
+protected:
+    virtual void InitEntry(NSchemeCache::TSchemeCacheNavigate::TEntry& entry) = 0;
+    virtual TString DebugString() const = 0;
 public:
     static NKikimrServices::TActivity::EType ActorActivityType();
     void Bootstrap();
@@ -59,13 +83,52 @@ public:
                 return;
         }
     }
-    TSchemeDescriptionActor(ISchemeDescribeController::TPtr controller, const TString& reqId, const TString& path)
+    TSchemeDescriptionActorImpl(ISchemeDescribeController::TPtr controller, const TString& reqId)
         : Controller(controller)
-        , Path(path)
         , RequestId(reqId)
     {
 
     }
 };
 
+class TSchemeDescriptionActor: public TSchemeDescriptionActorImpl {
+private:
+    using TBase = TSchemeDescriptionActorImpl;
+    TString Path;
+protected:
+    virtual void InitEntry(NSchemeCache::TSchemeCacheNavigate::TEntry& entry) override {
+        entry.RequestType = NSchemeCache::TSchemeCacheNavigate::TEntry::ERequestType::ByPath;
+        entry.Path = NKikimr::SplitPath(Path);
+    }
+    virtual TString DebugString() const override {
+        return "PATH:" + Path;
+    }
+public:
+    TSchemeDescriptionActor(ISchemeDescribeController::TPtr controller, const TString& reqId, const TString& path)
+        : TBase(controller, reqId)
+        , Path(path) {
+
+    }
+};
+
+class TSchemeDescriptionActorByTableId: public TSchemeDescriptionActorImpl {
+private:
+    using TBase = TSchemeDescriptionActorImpl;
+    const TTableId TableId;
+    virtual TString DebugString() const override {
+        return "TableId:" + TableId.PathId.ToString();
+    }
+protected:
+    virtual void InitEntry(NSchemeCache::TSchemeCacheNavigate::TEntry& entry) override {
+        entry.RequestType = NSchemeCache::TSchemeCacheNavigate::TEntry::ERequestType::ByTableId;
+        entry.TableId = TableId;
+    }
+public:
+    TSchemeDescriptionActorByTableId(ISchemeDescribeController::TPtr controller, const TString& reqId, const TTableId& tableId)
+        : TBase(controller, reqId)
+        , TableId(tableId) {
+
+    }
+};
+
 }
diff --git a/ydb/services/metadata/initializer/accessor_init.cpp b/ydb/services/metadata/initializer/accessor_init.cpp
index cab2f2d9492..af6df1372a7 100644
--- a/ydb/services/metadata/initializer/accessor_init.cpp
+++ b/ydb/services/metadata/initializer/accessor_init.cpp
@@ -20,6 +20,23 @@ void TDSAccessorInitialized::Handle(TEvInitializerPreparationStart::TPtr& /*ev*/
     InitializationBehaviour->Prepare(InternalController);
 }
 
+class TModifierController: public NMetadata::NInitializer::IModifierExternalController {
+private:
+    const TActorIdentity OwnerId;
+public:
+    TModifierController(const TActorIdentity& ownerId)
+        : OwnerId(ownerId)
+    {
+
+    }
+    virtual void OnModificationFinished(const TString& /*modificationId*/) override {
+        OwnerId.Send(OwnerId, new NModifications::TEvModificationFinished());
+    }
+    virtual void OnModificationFailed(const TString& errorMessage, const TString& /*modificationId*/) override {
+        OwnerId.Send(OwnerId, new NModifications::TEvModificationProblem(errorMessage));
+    }
+};
+
 void TDSAccessorInitialized::Handle(TEvInitializerPreparationFinished::TPtr& ev) {
     auto modifiers = ev->Get()->GetModifiers();
     for (auto&& i : modifiers) {
@@ -31,7 +48,7 @@ void TDSAccessorInitialized::Handle(TEvInitializerPreparationFinished::TPtr& ev)
     }
     if (Modifiers.size()) {
         ALS_INFO(NKikimrServices::METADATA_INITIALIZER) << "modifiers count: " << Modifiers.size();
-        Modifiers.front()->Execute(SelfId(), Config);
+        Modifiers.front()->Execute(std::make_shared<TModifierController>(SelfId()), Config);
     } else {
         ALS_INFO(NKikimrServices::METADATA_INITIALIZER) << "initialization finished";
         ExternalController->OnInitializationFinished(ComponentId);
@@ -46,7 +63,7 @@ void TDSAccessorInitialized::Handle(TEvInitializerPreparationProblem::TPtr& ev)
 void TDSAccessorInitialized::DoNextModifier() {
     Modifiers.pop_front();
     if (Modifiers.size()) {
-        Modifiers.front()->Execute(SelfId(), Config);
+        Modifiers.front()->Execute(std::make_shared<TModifierController>(SelfId()), Config);
     } else {
         ALS_INFO(NKikimrServices::METADATA_INITIALIZER) << "initialization finished";
         ExternalController->OnInitializationFinished(ComponentId);
@@ -58,8 +75,11 @@ void TDSAccessorInitialized::Handle(NRequest::TEvRequestFinished::TPtr& /*ev*/)
     Y_VERIFY(Modifiers.size());
     if (NProvider::TServiceOperator::IsEnabled() && InitializationSnapshot) {
         TDBInitialization dbInit(ComponentId, Modifiers.front()->GetModificationId());
+        NModifications::IOperationsManager::TExternalModificationContext extContext;
+        extContext.SetUserToken(NACLib::TSystemUsers::Metadata());
         auto alterCommand = std::make_shared<NModifications::TCreateCommand<TDBInitialization>>(
-            dbInit.SerializeToRecord(), TDBInitialization::GetBehaviour(), InternalController, NModifications::IOperationsManager::TModificationContext());
+            dbInit.SerializeToRecord(), TDBInitialization::GetBehaviour(), InternalController,
+            NModifications::IOperationsManager::TInternalModificationContext(extContext));
         Sender<NProvider::TEvObjectsOperation>(alterCommand)
             .SendTo(NProvider::MakeServiceId(SelfId().NodeId()));
     } else {
diff --git a/ydb/services/metadata/initializer/common.h b/ydb/services/metadata/initializer/common.h
index b5e6206901c..95df048cc03 100644
--- a/ydb/services/metadata/initializer/common.h
+++ b/ydb/services/metadata/initializer/common.h
@@ -6,11 +6,19 @@ namespace NKikimr::NMetadata::NInitializer {
 
 class TACLModifierConstructor;
 
+class IModifierExternalController {
+public:
+    using TPtr = std::shared_ptr<IModifierExternalController>;
+    virtual ~IModifierExternalController() = default;
+    virtual void OnModificationFinished(const TString& modificationId) = 0;
+    virtual void OnModificationFailed(const TString& errorMessage, const TString& modificationId) = 0;
+};
+
 class ITableModifier {
 private:
     YDB_READONLY_DEF(TString, ModificationId);
 protected:
-    virtual bool DoExecute(const TActorId& resultCallbackId, const NRequest::TConfig& config) const = 0;
+    virtual bool DoExecute(IModifierExternalController::TPtr externalController, const NRequest::TConfig& config) const = 0;
 public:
     using TPtr = std::shared_ptr<ITableModifier>;
     virtual ~ITableModifier() = default;
@@ -21,8 +29,8 @@ public:
 
     }
 
-    bool Execute(const TActorId& resultCallbackId, const NRequest::TConfig& config) const {
-        return DoExecute(resultCallbackId, config);
+    bool Execute(IModifierExternalController::TPtr externalController, const NRequest::TConfig& config) const {
+        return DoExecute(externalController, config);
     }
 };
 
@@ -32,9 +40,29 @@ private:
     using TBase = ITableModifier;
     YDB_READONLY_DEF(typename TDialogPolicy::TRequest, Request);
 protected:
-    virtual bool DoExecute(const TActorId& resultCallbackId, const NRequest::TConfig& config) const override {
-        TActivationContext::ActorSystem()->Register(new NRequest::TYDBRequest<TDialogPolicy>(Request,
-            NACLib::TSystemUsers::Metadata(), resultCallbackId, config));
+    class TAdapterController: public NRequest::IExternalController<TDialogPolicy> {
+    private:
+        IModifierExternalController::TPtr ExternalController;
+        const TString ModificationId;
+    public:
+        TAdapterController(IModifierExternalController::TPtr externalController, const TString& modificationId)
+            : ExternalController(externalController)
+            , ModificationId(modificationId)
+        {
+
+        }
+
+        virtual void OnRequestResult(typename TDialogPolicy::TResponse&& /*result*/) override {
+            ExternalController->OnModificationFinished(ModificationId);
+        }
+        virtual void OnRequestFailed(const TString& errorMessage) override {
+            ExternalController->OnModificationFailed(errorMessage, ModificationId);
+        }
+    };
+
+    virtual bool DoExecute(IModifierExternalController::TPtr externalController, const NRequest::TConfig& config) const override {
+        TActivationContext::ActorSystem()->Register(new NRequest::TYDBControllerRequest<TDialogPolicy>(Request,
+            NACLib::TSystemUsers::Metadata(), std::make_shared<TAdapterController>(externalController, GetModificationId()), config));
         return true;
     }
 public:
diff --git a/ydb/services/metadata/initializer/manager.cpp b/ydb/services/metadata/initializer/manager.cpp
index 079e78b216f..0856618f2eb 100644
--- a/ydb/services/metadata/initializer/manager.cpp
+++ b/ydb/services/metadata/initializer/manager.cpp
@@ -5,14 +5,14 @@ namespace NKikimr::NMetadata::NInitializer {
 
 void TManager::DoPrepareObjectsBeforeModification(std::vector<TDBInitialization>&& objects,
     NModifications::IAlterPreparationController<TDBInitialization>::TPtr controller,
-    const TModificationContext& /*context*/) const
+    const TInternalModificationContext& /*context*/) const
 {
     controller->OnPreparationFinished(std::move(objects));
 }
 
 NModifications::TOperationParsingResult TManager::DoBuildPatchFromSettings(
     const NYql::TObjectSettingsImpl& /*settings*/,
-    const TModificationContext& /*context*/) const {
+    TInternalModificationContext& /*context*/) const {
     NInternal::TTableRecord result;
     return result;
 }
diff --git a/ydb/services/metadata/initializer/manager.h b/ydb/services/metadata/initializer/manager.h
index 7c004d33abf..036227b7b3c 100644
--- a/ydb/services/metadata/initializer/manager.h
+++ b/ydb/services/metadata/initializer/manager.h
@@ -11,14 +11,14 @@ namespace NKikimr::NMetadata::NInitializer {
 class TManager: public NModifications::TGenericOperationsManager<TDBInitialization> {
 private:
     using TBase = NModifications::TGenericOperationsManager<TDBInitialization>;
-    using TModificationContext = TBase::TModificationContext;
+    using TInternalModificationContext = TBase::TInternalModificationContext;
 protected:
     virtual void DoPrepareObjectsBeforeModification(std::vector<TDBInitialization>&& objects,
         NModifications::IAlterPreparationController<TDBInitialization>::TPtr controller,
-        const TModificationContext& /*context*/) const override;
+        const TInternalModificationContext& context) const override;
 
     virtual NModifications::TOperationParsingResult DoBuildPatchFromSettings(const NYql::TObjectSettingsImpl& /*settings*/,
-        const TModificationContext& /*context*/) const override;
+        TInternalModificationContext& context) const override;
 
 public:
 };
diff --git a/ydb/services/metadata/manager/abstract.cpp b/ydb/services/metadata/manager/abstract.cpp
index b4f788adce5..b824874d722 100644
--- a/ydb/services/metadata/manager/abstract.cpp
+++ b/ydb/services/metadata/manager/abstract.cpp
@@ -34,25 +34,37 @@ NKikimr::NMetadata::NModifications::TTableSchema& TTableSchema::AddColumn(const
     return *this;
 }
 
-NThreading::TFuture<NKikimr::NMetadata::NModifications::TObjectOperatorResult> IOperationsManager::DropObject(const NYql::TDropObjectSettings& settings, const ui32 nodeId, IClassBehaviour::TPtr manager, const TModificationContext& context) const {
+NThreading::TFuture<NKikimr::NMetadata::NModifications::TObjectOperatorResult> IOperationsManager::DropObject(const NYql::TDropObjectSettings& settings,
+    const ui32 nodeId, IClassBehaviour::TPtr manager, const TExternalModificationContext& context) const
+{
     if (!NMetadata::NProvider::TServiceOperator::IsEnabled()) {
         return NThreading::MakeFuture<TObjectOperatorResult>("metadata provider service is disabled");
     }
-    return DoDropObject(settings, nodeId, manager, context);
+    TInternalModificationContext internalContext(context);
+    internalContext.SetActivityType(EActivityType::Drop);
+    return DoModify(settings, nodeId, manager, internalContext);
 }
 
-NThreading::TFuture<NKikimr::NMetadata::NModifications::TObjectOperatorResult> IOperationsManager::AlterObject(const NYql::TAlterObjectSettings& settings, const ui32 nodeId, IClassBehaviour::TPtr manager, const TModificationContext& context) const {
+NThreading::TFuture<NKikimr::NMetadata::NModifications::TObjectOperatorResult> IOperationsManager::AlterObject(const NYql::TAlterObjectSettings& settings,
+    const ui32 nodeId, IClassBehaviour::TPtr manager, const TExternalModificationContext& context) const
+{
     if (!NMetadata::NProvider::TServiceOperator::IsEnabled()) {
         return NThreading::MakeFuture<TObjectOperatorResult>("metadata provider service is disabled");
     }
-    return DoAlterObject(settings, nodeId, manager, context);
+    TInternalModificationContext internalContext(context);
+    internalContext.SetActivityType(EActivityType::Alter);
+    return DoModify(settings, nodeId, manager, internalContext);
 }
 
-NThreading::TFuture<NKikimr::NMetadata::NModifications::TObjectOperatorResult> IOperationsManager::CreateObject(const NYql::TCreateObjectSettings& settings, const ui32 nodeId, IClassBehaviour::TPtr manager, const TModificationContext& context) const {
+NThreading::TFuture<NKikimr::NMetadata::NModifications::TObjectOperatorResult> IOperationsManager::CreateObject(const NYql::TCreateObjectSettings& settings,
+    const ui32 nodeId, IClassBehaviour::TPtr manager, const TExternalModificationContext& context) const
+{
     if (!NMetadata::NProvider::TServiceOperator::IsEnabled()) {
         return NThreading::MakeFuture<TObjectOperatorResult>("metadata provider service is disabled");
     }
-    return DoCreateObject(settings, nodeId, manager, context);
+    TInternalModificationContext internalContext(context);
+    internalContext.SetActivityType(EActivityType::Create);
+    return DoModify(settings, nodeId, manager, internalContext);
 }
 
 }
diff --git a/ydb/services/metadata/manager/abstract.h b/ydb/services/metadata/manager/abstract.h
index ae1bfb3a793..f288081ec34 100644
--- a/ydb/services/metadata/manager/abstract.h
+++ b/ydb/services/metadata/manager/abstract.h
@@ -21,6 +21,19 @@ private:
     using TFeatures = std::map<TString, TString>;
     YDB_READONLY_DEF(TFeatures, Features);
 public:
+    template <class T>
+    std::optional<T> GetFeature(const TString& featureId, const std::optional<T> noExistsValue = {}) const {
+        T result;
+        auto it = Features.find(featureId);
+        if (it == Features.end()) {
+            return noExistsValue;
+        } else if (TryFromString(it->second, result)) {
+            return result;
+        } else {
+            return {};
+        }
+    }
+
     template <class TKiObject>
     bool DeserializeFromKi(const TKiObject& data) {
         ObjectId = data.ObjectId();
@@ -39,17 +52,9 @@ public:
     }
 };
 
-struct TCreateObjectSettings: public TObjectSettingsImpl {
-public:
-};
-
-struct TAlterObjectSettings: public TObjectSettingsImpl {
-public:
-};
-
-struct TDropObjectSettings: public TObjectSettingsImpl {
-public:
-};
+using TCreateObjectSettings = TObjectSettingsImpl;
+using TAlterObjectSettings = TObjectSettingsImpl;
+using TDropObjectSettings = TObjectSettingsImpl;
 
 }
 
@@ -140,33 +145,40 @@ public:
         Drop
     };
 
-    class TModificationContext {
+    class TExternalModificationContext {
     private:
         YDB_ACCESSOR_DEF(std::optional<NACLib::TUserToken>, UserToken);
+    public:
+        TExternalModificationContext() = default;
+    };
+
+    class TInternalModificationContext {
+    private:
+        YDB_READONLY_DEF(TExternalModificationContext, ExternalData);
         YDB_ACCESSOR(EActivityType, ActivityType, EActivityType::Undefined);
     public:
-        TModificationContext() = default;
+        TInternalModificationContext(const TExternalModificationContext& externalData)
+            : ExternalData(externalData)
+        {
+
+        }
     };
 private:
     YDB_ACCESSOR_DEF(std::optional<TTableSchema>, ActualSchema);
 protected:
-    virtual NThreading::TFuture<TObjectOperatorResult> DoCreateObject(const NYql::TCreateObjectSettings& settings, const ui32 nodeId,
-        IClassBehaviour::TPtr manager, const TModificationContext& context) const = 0;
-    virtual NThreading::TFuture<TObjectOperatorResult> DoAlterObject(const NYql::TAlterObjectSettings& settings, const ui32 nodeId,
-        IClassBehaviour::TPtr manager, const TModificationContext& context) const = 0;
-    virtual NThreading::TFuture<TObjectOperatorResult> DoDropObject(const NYql::TDropObjectSettings& settings, const ui32 nodeId,
-        IClassBehaviour::TPtr manager, const TModificationContext& context) const = 0;
+    virtual NThreading::TFuture<TObjectOperatorResult> DoModify(const NYql::TObjectSettingsImpl& settings, const ui32 nodeId,
+        IClassBehaviour::TPtr manager, TInternalModificationContext& context) const = 0;
 public:
     virtual ~IOperationsManager() = default;
 
     NThreading::TFuture<TObjectOperatorResult> CreateObject(const NYql::TCreateObjectSettings& settings, const ui32 nodeId,
-        IClassBehaviour::TPtr manager, const TModificationContext& context) const;
+        IClassBehaviour::TPtr manager, const TExternalModificationContext& context) const;
 
     NThreading::TFuture<TObjectOperatorResult> AlterObject(const NYql::TAlterObjectSettings& settings, const ui32 nodeId,
-        IClassBehaviour::TPtr manager, const TModificationContext& context) const;
+        IClassBehaviour::TPtr manager, const TExternalModificationContext& context) const;
 
     NThreading::TFuture<TObjectOperatorResult> DropObject(const NYql::TDropObjectSettings& settings, const ui32 nodeId,
-        IClassBehaviour::TPtr manager, const TModificationContext& context) const;
+        IClassBehaviour::TPtr manager, const TExternalModificationContext& context) const;
 
     const TTableSchema& GetSchema() const {
         Y_VERIFY(!!ActualSchema);
@@ -178,21 +190,21 @@ template <class TObject>
 class IObjectOperationsManager: public IOperationsManager {
 protected:
     virtual TOperationParsingResult DoBuildPatchFromSettings(const NYql::TObjectSettingsImpl& settings,
-        const TModificationContext& context) const = 0;
+        TInternalModificationContext& context) const = 0;
     virtual void DoPrepareObjectsBeforeModification(std::vector<TObject>&& patchedObjects,
         typename IAlterPreparationController<TObject>::TPtr controller,
-        const IOperationsManager::TModificationContext& context) const = 0;
+        const TInternalModificationContext& context) const = 0;
 public:
     using TPtr = std::shared_ptr<IObjectOperationsManager<TObject>>;
 
     TOperationParsingResult BuildPatchFromSettings(const NYql::TObjectSettingsImpl& settings,
-        const IOperationsManager::TModificationContext& context) const {
+        IOperationsManager::TInternalModificationContext& context) const {
         return DoBuildPatchFromSettings(settings, context);
     }
 
     void PrepareObjectsBeforeModification(std::vector<TObject>&& patchedObjects,
         typename NModifications::IAlterPreparationController<TObject>::TPtr controller,
-        const IOperationsManager::TModificationContext& context) const {
+        const TInternalModificationContext& context) const {
         return DoPrepareObjectsBeforeModification(std::move(patchedObjects), controller, context);
     }
 };
@@ -203,7 +215,7 @@ private:
     YDB_ACCESSOR_DEF(IClassBehaviour::TPtr, Behaviour);
     YDB_READONLY_DEF(IAlterController::TPtr, Controller);
 protected:
-    mutable IOperationsManager::TModificationContext Context;
+    IOperationsManager::TInternalModificationContext Context;
     virtual void DoExecute() const = 0;
 public:
     using TPtr = std::shared_ptr<IAlterCommand>;
@@ -216,14 +228,14 @@ public:
         return result;
     }
 
-    const IOperationsManager::TModificationContext& GetContext() const {
+    const IOperationsManager::TInternalModificationContext& GetContext() const {
         return Context;
     }
 
     IAlterCommand(const std::vector<NInternal::TTableRecord>& records,
         IClassBehaviour::TPtr behaviour,
         NModifications::IAlterController::TPtr controller,
-        const IOperationsManager::TModificationContext& context)
+        const IOperationsManager::TInternalModificationContext& context)
         : Records(records)
         , Behaviour(behaviour)
         , Controller(controller)
@@ -234,7 +246,7 @@ public:
     IAlterCommand(const NInternal::TTableRecord& record,
         IClassBehaviour::TPtr behaviour,
         NModifications::IAlterController::TPtr controller,
-        const IOperationsManager::TModificationContext& context)
+        const IOperationsManager::TInternalModificationContext& context)
         : Behaviour(behaviour)
         , Controller(controller)
         , Context(context) {
diff --git a/ydb/services/metadata/manager/alter.h b/ydb/services/metadata/manager/alter.h
index 57301997840..e2056d640a1 100644
--- a/ydb/services/metadata/manager/alter.h
+++ b/ydb/services/metadata/manager/alter.h
@@ -16,7 +16,7 @@ private:
 protected:
     virtual bool ProcessPreparedObjects(NInternal::TTableRecords&& records) const override {
         TBase::Register(new TUpdateObjectsActor<TObject>(std::move(records), TBase::UserToken,
-            TBase::InternalController, TBase::SessionId, TBase::TransactionId, TBase::Context.GetUserToken()));
+            TBase::InternalController, TBase::SessionId, TBase::TransactionId, TBase::Context.GetExternalData().GetUserToken()));
         return true;
     }
 
@@ -34,7 +34,8 @@ private:
 protected:
     virtual bool ProcessPreparedObjects(NInternal::TTableRecords&& records) const override {
         TBase::Register(new TInsertObjectsActor<TObject>(std::move(records), TBase::UserToken,
-            TBase::InternalController, TBase::SessionId, TBase::TransactionId, TBase::Context.GetUserToken()));
+            TBase::InternalController, TBase::SessionId, TBase::TransactionId,
+            TBase::Context.GetExternalData().GetUserToken()));
         return true;
     }
 
@@ -79,7 +80,7 @@ public:
 
     virtual bool ProcessPreparedObjects(NInternal::TTableRecords&& records) const override {
         TBase::Register(new TDeleteObjectsActor<TObject>(std::move(records), TBase::UserToken,
-            TBase::InternalController, TBase::SessionId, TBase::TransactionId, TBase::Context.GetUserToken()));
+            TBase::InternalController, TBase::SessionId, TBase::TransactionId, TBase::Context.GetExternalData().GetUserToken()));
         return true;
     }
 
@@ -96,7 +97,6 @@ private:
 protected:
     virtual void DoExecute() const override {
         typename IObjectOperationsManager<TObject>::TPtr manager = TBase::GetOperationsManagerFor<TObject>();
-        Context.SetActivityType(IOperationsManager::EActivityType::Create);
         TActivationContext::AsActorContext().Register(new TCreateActor<TObject>(GetRecords(), GetController(), manager, GetContext()));
     }
 public:
@@ -110,7 +110,6 @@ private:
 protected:
     virtual void DoExecute() const override {
         typename IObjectOperationsManager<TObject>::TPtr manager = TBase::GetOperationsManagerFor<TObject>();
-        Context.SetActivityType(IOperationsManager::EActivityType::Alter);
         TActivationContext::AsActorContext().Register(new TAlterActor<TObject>(GetRecords(), GetController(), manager, GetContext()));
     }
 public:
@@ -124,7 +123,6 @@ private:
 protected:
     virtual void DoExecute() const override {
         typename IObjectOperationsManager<TObject>::TPtr manager = TBase::GetOperationsManagerFor<TObject>();
-        Context.SetActivityType(IOperationsManager::EActivityType::Drop);
         TActivationContext::AsActorContext().Register(new TDropActor<TObject>(GetRecords(), GetController(), manager, GetContext()));
     }
 public:
diff --git a/ydb/services/metadata/manager/alter_impl.h b/ydb/services/metadata/manager/alter_impl.h
index 685958f8829..c91df7aeb24 100644
--- a/ydb/services/metadata/manager/alter_impl.h
+++ b/ydb/services/metadata/manager/alter_impl.h
@@ -55,7 +55,7 @@ protected:
     typename TProcessingController<TObject>::TPtr InternalController;
     IAlterController::TPtr ExternalController;
     typename IObjectOperationsManager<TObject>::TPtr Manager;
-    const IOperationsManager::TModificationContext Context;
+    const IOperationsManager::TInternalModificationContext Context;
     std::vector<NInternal::TTableRecord> Patches;
     NInternal::TTableRecords RestoreObjectIds;
     const NACLib::TUserToken UserToken = NACLib::TSystemUsers::Metadata();
@@ -67,7 +67,7 @@ public:
     TModificationActorImpl(NInternal::TTableRecord&& patch,
         IAlterController::TPtr controller,
         typename IObjectOperationsManager<TObject>::TPtr manager,
-        const IOperationsManager::TModificationContext& context)
+        const IOperationsManager::TInternalModificationContext& context)
         : ExternalController(controller)
         , Manager(manager)
         , Context(context) {
@@ -76,7 +76,7 @@ public:
 
     TModificationActorImpl(const NInternal::TTableRecord& patch, IAlterController::TPtr controller,
         typename IObjectOperationsManager<TObject>::TPtr manager,
-        const IOperationsManager::TModificationContext& context)
+        const IOperationsManager::TInternalModificationContext& context)
         : ExternalController(controller)
         , Manager(manager)
         , Context(context) {
@@ -85,7 +85,7 @@ public:
 
     TModificationActorImpl(std::vector<NInternal::TTableRecord>&& patches, IAlterController::TPtr controller,
         typename IObjectOperationsManager<TObject>::TPtr manager,
-        const IOperationsManager::TModificationContext& context)
+        const IOperationsManager::TInternalModificationContext& context)
         : ExternalController(controller)
         , Manager(manager)
         , Context(context)
@@ -95,7 +95,7 @@ public:
 
     TModificationActorImpl(const std::vector<NInternal::TTableRecord>& patches, IAlterController::TPtr controller,
         typename IObjectOperationsManager<TObject>::TPtr manager,
-        const IOperationsManager::TModificationContext& context)
+        const IOperationsManager::TInternalModificationContext& context)
         : ExternalController(controller)
         , Manager(manager)
         , Context(context)
diff --git a/ydb/services/metadata/manager/generic_manager.h b/ydb/services/metadata/manager/generic_manager.h
index d4a12cbc534..dc10ae4aaa6 100644
--- a/ydb/services/metadata/manager/generic_manager.h
+++ b/ydb/services/metadata/manager/generic_manager.h
@@ -28,12 +28,11 @@ class TGenericOperationsManager: public IObjectOperationsManager<T> {
 private:
     using TBase = IObjectOperationsManager<T>;
 public:
-    using TModificationContext = typename TBase::TModificationContext;
-private:
-    template <class TCommand, class TSettings>
-    NThreading::TFuture<TObjectOperatorResult> DoModifyObject(
-        const TSettings& settings, const ui32 nodeId,
-        IClassBehaviour::TPtr manager, const TModificationContext& context) const
+    using TInternalModificationContext = typename TBase::TInternalModificationContext;
+protected:
+    virtual NThreading::TFuture<TObjectOperatorResult> DoModify(
+        const NYql::TObjectSettingsImpl& settings, const ui32 nodeId,
+        IClassBehaviour::TPtr manager, TInternalModificationContext& context) const override
     {
         if (!manager) {
             TObjectOperatorResult result("modification object behaviour not initialized");
@@ -43,38 +42,33 @@ private:
             TObjectOperatorResult result("modification is unavailable for " + manager->GetTypeId());
             return NThreading::MakeFuture<TObjectOperatorResult>(result);
         }
-        TOperationParsingResult patch(TBase::BuildPatchFromSettings(settings, context));
-        if (!patch.IsSuccess()) {
-            TObjectOperatorResult result(patch.GetErrorMessage());
-            return NThreading::MakeFuture<TObjectOperatorResult>(result);
-        }
         auto promise = NThreading::NewPromise<TObjectOperatorResult>();
         auto result = promise.GetFuture();
-        auto c = std::make_shared<TOperationsController>(std::move(promise));
-        auto command = std::make_shared<TCommand>(patch.GetRecord(), manager, c, context);
-        TActivationContext::Send(new IEventHandleFat(NProvider::MakeServiceId(nodeId), {},
-            new NProvider::TEvObjectsOperation(command)));
+        {
+            TOperationParsingResult patch(TBase::BuildPatchFromSettings(settings, context));
+            if (!patch.IsSuccess()) {
+                TObjectOperatorResult result(patch.GetErrorMessage());
+                return NThreading::MakeFuture<TObjectOperatorResult>(result);
+            }
+            auto c = std::make_shared<TOperationsController>(std::move(promise));
+            IAlterCommand::TPtr alterCommand;
+            switch (context.GetActivityType()) {
+                case IOperationsManager::EActivityType::Create:
+                    alterCommand = std::make_shared<TCreateCommand<T>>(patch.GetRecord(), manager, c, context);
+                    break;
+                case IOperationsManager::EActivityType::Alter:
+                    alterCommand = std::make_shared<TAlterCommand<T>>(patch.GetRecord(), manager, c, context);
+                    break;
+                case IOperationsManager::EActivityType::Drop:
+                    alterCommand = std::make_shared<TDropCommand<T>>(patch.GetRecord(), manager, c, context);
+                    break;
+                case IOperationsManager::EActivityType::Undefined:
+                    return NThreading::MakeFuture<TObjectOperatorResult>(TObjectOperatorResult("undefined action type"));
+            }
+            TActivationContext::Send(new IEventHandleFat(NProvider::MakeServiceId(nodeId), {}, new NProvider::TEvObjectsOperation(alterCommand)));
+        }
         return result;
     }
-protected:
-    virtual NThreading::TFuture<TObjectOperatorResult> DoCreateObject(
-        const NYql::TCreateObjectSettings& settings, const ui32 nodeId,
-        IClassBehaviour::TPtr manager, const TModificationContext& context) const override
-    {
-        return DoModifyObject<TCreateCommand<T>>(settings, nodeId, manager, context);
-    }
-    virtual NThreading::TFuture<TObjectOperatorResult> DoAlterObject(
-        const NYql::TAlterObjectSettings& settings, const ui32 nodeId,
-        IClassBehaviour::TPtr manager, const TModificationContext& context) const override
-    {
-        return DoModifyObject<TAlterCommand<T>>(settings, nodeId, manager, context);
-    }
-    virtual NThreading::TFuture<TObjectOperatorResult> DoDropObject(
-        const NYql::TDropObjectSettings& settings, const ui32 nodeId,
-        IClassBehaviour::TPtr manager, const TModificationContext& context) const override
-    {
-        return DoModifyObject<TDropCommand<T>>(settings, nodeId, manager, context);
-    }
 public:
 };
 
diff --git a/ydb/services/metadata/manager/table_record.cpp b/ydb/services/metadata/manager/table_record.cpp
index c6ed3ae94f4..5d843540968 100644
--- a/ydb/services/metadata/manager/table_record.cpp
+++ b/ydb/services/metadata/manager/table_record.cpp
@@ -201,7 +201,7 @@ Ydb::Table::ExecuteDataQueryRequest TTableRecords::BuildUpsertQuery(const TStrin
     sb << "DECLARE $objects AS List<" << BuildColumnsSchemaStruct() << ">;" << Endl;
     sb << "UPSERT INTO `" + tablePath + "`" << Endl;
     sb << "SELECT " << JoinSeq(",", GetColumnIds()) << " FROM AS_TABLE($objects)" << Endl;
-    Cerr << sb << Endl;
+    ALS_DEBUG(NKikimrServices::METADATA_PROVIDER) << sb;
     result.mutable_query()->set_yql_text(sb);
     (*result.mutable_parameters())["$objects"] = BuildVariableStructRecords();
     return result;
@@ -213,7 +213,7 @@ Ydb::Table::ExecuteDataQueryRequest TTableRecords::BuildInsertQuery(const TStrin
     sb << "DECLARE $objects AS List<" << BuildColumnsSchemaStruct() << ">;" << Endl;
     sb << "INSERT INTO `" + tablePath + "`" << Endl;
     sb << "SELECT " << JoinSeq(",", GetColumnIds()) << " FROM AS_TABLE($objects)" << Endl;
-    Cerr << sb << Endl;
+    ALS_DEBUG(NKikimrServices::METADATA_PROVIDER) << sb;
     result.mutable_query()->set_yql_text(sb);
     (*result.mutable_parameters())["$objects"] = BuildVariableStructRecords();
     return result;
@@ -229,7 +229,7 @@ Ydb::Table::ExecuteDataQueryRequest TTableRecords::BuildSelectQuery(const TStrin
     } else if (GetColumnIds().size() == 1) {
         sb << "WHERE " << GetColumnIds()[0] << " IN $ids" << Endl;
     }
-    Cerr << sb << Endl;
+    ALS_DEBUG(NKikimrServices::METADATA_PROVIDER) << sb;
     result.mutable_query()->set_yql_text(sb);
     (*result.mutable_parameters())["$ids"] = BuildVariableTupleRecords();
     return result;
@@ -241,7 +241,7 @@ Ydb::Table::ExecuteDataQueryRequest TTableRecords::BuildDeleteQuery(const TStrin
     sb << "DECLARE $ids AS List<" << BuildColumnsSchemaTuple() << ">;" << Endl;
     sb << "DELETE FROM `" + tablePath + "`" << Endl;
     sb << "WHERE (" << JoinSeq(", ", GetColumnIds()) << ") IN $ids" << Endl;
-    Cerr << sb << Endl;
+    ALS_DEBUG(NKikimrServices::METADATA_PROVIDER) << sb;
     result.mutable_query()->set_yql_text(sb);
     (*result.mutable_parameters())["$ids"] = BuildVariableTupleRecords();
     return result;
@@ -253,7 +253,7 @@ Ydb::Table::ExecuteDataQueryRequest TTableRecords::BuildUpdateQuery(const TStrin
     sb << "DECLARE $objects AS List<" << BuildColumnsSchemaStruct() << ">;" << Endl;
     sb << "UPDATE `" + tablePath + "` ON" << Endl;
     sb << "SELECT " << JoinSeq(",", GetColumnIds()) << " FROM AS_TABLE($objects)" << Endl;
-    Cerr << sb << Endl;
+    ALS_DEBUG(NKikimrServices::METADATA_PROVIDER) << sb;
     result.mutable_query()->set_yql_text(sb);
     (*result.mutable_parameters())["$objects"] = BuildVariableStructRecords();
     return result;
diff --git a/ydb/services/metadata/manager/ydb_value_operator.cpp b/ydb/services/metadata/manager/ydb_value_operator.cpp
index 783c6706162..e448526475b 100644
--- a/ydb/services/metadata/manager/ydb_value_operator.cpp
+++ b/ydb/services/metadata/manager/ydb_value_operator.cpp
@@ -120,6 +120,12 @@ Ydb::Value TYDBValue::UInt64(const ui64 value) {
     return result;
 }
 
+Ydb::Value TYDBValue::Bool(const bool value) {
+    Ydb::Value result;
+    result.set_bool_value(value);
+    return result;
+}
+
 Ydb::Value TYDBValue::UInt32(const ui32 value) {
     Ydb::Value result;
     result.set_uint32_value(value);
@@ -161,4 +167,84 @@ Ydb::Column TYDBColumn::UInt32(const TString& columnId) {
     return result;
 }
 
+Ydb::Type TYDBType::Primitive(const Ydb::Type::PrimitiveTypeId type) {
+    Ydb::Type result;
+    result.set_type_id(type);
+    return result;
+}
+
+std::optional<Ydb::Type::PrimitiveTypeId> TYDBType::ConvertYQLToYDB(const NScheme::TTypeId type) {
+    switch (type) {
+        case NScheme::NTypeIds::Int8:
+            return Ydb::Type::INT8;
+        case NScheme::NTypeIds::Int16:
+            return Ydb::Type::INT16;
+        case NScheme::NTypeIds::Int32:
+            return Ydb::Type::INT32;
+        case NScheme::NTypeIds::Int64:
+            return Ydb::Type::INT64;
+        case NScheme::NTypeIds::Uint8:
+            return Ydb::Type::UINT8;
+        case NScheme::NTypeIds::Uint16:
+            return Ydb::Type::UINT16;
+        case NScheme::NTypeIds::Uint32:
+            return Ydb::Type::UINT32;
+        case NScheme::NTypeIds::Uint64:
+            return Ydb::Type::UINT64;
+        case NScheme::NTypeIds::String:
+            return Ydb::Type::STRING;
+        case NScheme::NTypeIds::Utf8:
+            return Ydb::Type::UTF8;
+        case NScheme::NTypeIds::Timestamp:
+            return Ydb::Type::TIMESTAMP;
+        default:
+            return {};
+    }
+}
+
+std::optional<NKikimr::NScheme::TTypeId> TYDBType::ConvertYDBToYQL(const Ydb::Type::PrimitiveTypeId type) {
+    switch (type) {
+        case Ydb::Type::INT8:
+            return NScheme::NTypeIds::Int8;
+        case Ydb::Type::INT16:
+            return NScheme::NTypeIds::Int16;
+        case Ydb::Type::INT32:
+            return NScheme::NTypeIds::Int32;
+        case Ydb::Type::INT64:
+            return NScheme::NTypeIds::Int64;
+        case Ydb::Type::UINT8:
+            return NScheme::NTypeIds::Uint8;
+        case Ydb::Type::UINT16:
+            return NScheme::NTypeIds::Uint16;
+        case Ydb::Type::UINT32:
+            return NScheme::NTypeIds::Uint32;
+        case Ydb::Type::UINT64:
+            return NScheme::NTypeIds::Uint64;
+        case Ydb::Type::STRING:
+            return NScheme::NTypeIds::String;
+        case Ydb::Type::UTF8:
+            return NScheme::NTypeIds::Utf8;
+        case Ydb::Type::TIMESTAMP:
+            return NScheme::NTypeIds::Timestamp;
+        default:
+            return {};
+    }
+}
+
+std::optional<TVector<std::pair<TString, NScheme::TTypeInfo>>> TYDBType::ConvertYDBToYQL(const std::vector<std::pair<TString, Ydb::Type>>& input) {
+    TVector<std::pair<TString, NScheme::TTypeInfo>> resultLocal;
+    resultLocal.reserve(input.size());
+    for (auto&& i : input) {
+        if (!i.second.has_type_id()) {
+            return {};
+        }
+        auto yqlId = ConvertYDBToYQL(i.second.type_id());
+        if (!yqlId) {
+            return {};
+        }
+        resultLocal.emplace_back(std::make_pair(i.first, NScheme::TTypeInfo(*yqlId)));
+    }
+    return resultLocal;
+}
+
 }
diff --git a/ydb/services/metadata/manager/ydb_value_operator.h b/ydb/services/metadata/manager/ydb_value_operator.h
index 624e93a7821..c5de2d402d0 100644
--- a/ydb/services/metadata/manager/ydb_value_operator.h
+++ b/ydb/services/metadata/manager/ydb_value_operator.h
@@ -1,6 +1,9 @@
 #pragma once
 #include <ydb/public/api/protos/ydb_table.pb.h>
 #include <ydb/public/api/protos/ydb_value.pb.h>
+#include <ydb/public/lib/scheme_types/scheme_type_id.h>
+#include <ydb/core/scheme_types/scheme_type_info.h>
+#include <util/generic/vector.h>
 
 namespace NKikimr::NMetadata::NInternal {
 
@@ -13,6 +16,15 @@ public:
     static Ydb::Column UInt32(const TString& columnId);
 };
 
+class TYDBType {
+public:
+    static Ydb::Type Primitive(const Ydb::Type::PrimitiveTypeId type);
+    static std::optional<NScheme::TTypeId> ConvertYDBToYQL(const Ydb::Type::PrimitiveTypeId type);
+    static std::optional<Ydb::Type::PrimitiveTypeId> ConvertYQLToYDB(const NScheme::TTypeId type);
+
+    static std::optional<TVector<std::pair<TString, NScheme::TTypeInfo>>> ConvertYDBToYQL(const std::vector<std::pair<TString, Ydb::Type>>& input);
+};
+
 class TYDBValue {
 public:
     static bool IsSameType(const Ydb::Value& l, const Ydb::Type& type);
@@ -28,6 +40,7 @@ public:
     static Ydb::Value Utf8(const TStringBuf& value);
     static Ydb::Value UInt64(const ui64 value);
     static Ydb::Value UInt32(const ui32 value);
+    static Ydb::Value Bool(const bool value);
 };
 
 }
diff --git a/ydb/services/metadata/request/common.h b/ydb/services/metadata/request/common.h
index aa25f7a1101..58a849dee61 100644
--- a/ydb/services/metadata/request/common.h
+++ b/ydb/services/metadata/request/common.h
@@ -15,6 +15,11 @@ enum EEvents {
     EvCreateTableRequest = EventSpaceBegin(TKikimrEvents::ES_INTERNAL_REQUEST),
     EvCreateTableInternalResponse,
     EvCreateTableResponse,
+
+    EvDropTableRequest,
+    EvDropTableInternalResponse,
+    EvDropTableResponse,
+
     EvSelectRequest,
     EvSelectInternalResponse,
     EvSelectResponse,
diff --git a/ydb/services/metadata/request/request_actor.h b/ydb/services/metadata/request/request_actor.h
index 83a00e35e72..5eaf84b97e3 100644
--- a/ydb/services/metadata/request/request_actor.h
+++ b/ydb/services/metadata/request/request_actor.h
@@ -24,8 +24,19 @@ public:
     static constexpr ui32 EvResult = EvResultExt;
 };
 
+template <class TDialogPolicy>
+class IExternalController {
+public:
+    using TPtr = std::shared_ptr<IExternalController>;
+    virtual ~IExternalController() = default;
+    virtual void OnRequestResult(typename TDialogPolicy::TResponse&& result) = 0;
+    virtual void OnRequestFailed(const TString& errorMessage) = 0;
+};
+
 using TDialogCreateTable = TDialogPolicyImpl<Ydb::Table::CreateTableRequest, Ydb::Table::CreateTableResponse,
     EEvents::EvCreateTableRequest, EEvents::EvCreateTableInternalResponse, EEvents::EvCreateTableResponse>;
+using TDialogDropTable = TDialogPolicyImpl<Ydb::Table::DropTableRequest, Ydb::Table::DropTableResponse,
+    EEvents::EvDropTableRequest, EEvents::EvDropTableInternalResponse, EEvents::EvDropTableResponse>;
 using TDialogModifyPermissions = TDialogPolicyImpl<Ydb::Scheme::ModifyPermissionsRequest, Ydb::Scheme::ModifyPermissionsResponse,
     EEvents::EvModifyPermissionsRequest, EEvents::EvModifyPermissionsInternalResponse, EEvents::EvModifyPermissionsResponse>;
 using TDialogSelect = TDialogPolicyImpl<Ydb::Table::ExecuteDataQueryRequest, Ydb::Table::ExecuteDataQueryResponse,
@@ -48,6 +59,10 @@ class TEvRequestResult: public NActors::TEventLocal<TEvRequestResult<TDialogPoli
 private:
     YDB_READONLY_DEF(typename TDialogPolicy::TResponse, Result);
 public:
+    typename TDialogPolicy::TResponse&& DetachResult() {
+        return std::move(Result);
+    }
+
     TEvRequestResult(typename TDialogPolicy::TResponse&& result)
         : Result(std::move(result)) {
 
@@ -90,6 +105,15 @@ public:
     }
 };
 
+template <>
+class TOperatorChecker<Ydb::Table::DropTableResponse> {
+public:
+    static bool IsSuccess(const Ydb::Table::DropTableResponse& r) {
+        return r.operation().status() == Ydb::StatusIds::SUCCESS ||
+            r.operation().status() == Ydb::StatusIds::NOT_FOUND;
+    }
+};
+
 template <class TDialogPolicy>
 class TYDBOneRequest: public NActors::TActorBootstrapped<TYDBOneRequest<TDialogPolicy>> {
 private:
@@ -219,9 +243,40 @@ protected:
     }
 public:
 
-    TYDBCallbackRequest(const TRequest& request, const NACLib::TUserToken& uToken, const NActors::TActorId actorCallbackId)
+    TYDBCallbackRequest(const TRequest& request, const NACLib::TUserToken& uToken, const NActors::TActorId actorCallbackId, const TConfig& config = Default<TConfig>())
+        : TBase(request, uToken)
+        , CallbackActorId(actorCallbackId)
+        , Config(config)
+    {
+
+    }
+};
+
+template <class TDialogPolicy>
+class TYDBControllerRequest: public TYDBOneRequest<TDialogPolicy> {
+private:
+    using IExternalController = IExternalController<TDialogPolicy>;
+    using TBase = TYDBOneRequest<TDialogPolicy>;
+    using TRequest = typename TDialogPolicy::TRequest;
+    using TResponse = typename TDialogPolicy::TResponse;
+    typename IExternalController::TPtr ExternalController;
+    const TConfig Config;
+    ui32 Retry = 0;
+protected:
+    virtual void OnInternalResultError(const TString& errorMessage) override {
+        ExternalController->OnRequestFailed(errorMessage);
+        TBase::PassAway();
+    }
+    virtual void OnInternalResultSuccess(TResponse&& response) override {
+        ExternalController->OnRequestResult(std::move(response));
+    }
+public:
+
+    TYDBControllerRequest(const TRequest& request, const NACLib::TUserToken& uToken, typename IExternalController::TPtr externalController, const TConfig& config)
         : TBase(request, uToken)
-        , CallbackActorId(actorCallbackId) {
+        , ExternalController(externalController)
+        , Config(config)
+    {
 
     }
 };
@@ -241,7 +296,7 @@ private:
         Y_VERIFY(sessionId);
         std::optional<typename TDialogPolicy::TRequest> nextRequest = OnSessionId(sessionId);
         Y_VERIFY(nextRequest);
-        TBase::Register(new TYDBCallbackRequest<TDialogPolicy>(*nextRequest, UserToken, TBase::SelfId()));
+        TBase::Register(new TYDBCallbackRequest<TDialogPolicy>(*nextRequest, UserToken, TBase::SelfId(), Config));
     }
 protected:
     const TConfig Config;
@@ -281,7 +336,7 @@ public:
     }
 
     void Handle(typename TEvRequestStart::TPtr& /*ev*/) {
-        TBase::Register(new TYDBCallbackRequest<TDialogCreateSession>(TDialogCreateSession::TRequest(), UserToken, TBase::SelfId()));
+        TBase::Register(new TYDBCallbackRequest<TDialogCreateSession>(TDialogCreateSession::TRequest(), UserToken, TBase::SelfId(), Config));
     }
 
     void Bootstrap() {
@@ -290,6 +345,72 @@ public:
     }
 };
 
+template <class TDialogPolicy>
+class TSessionedActorCallback: public NActors::TActorBootstrapped<TSessionedActorCallback<TDialogPolicy>> {
+public:
+    using IExternalController = IExternalController<TDialogPolicy>;
+private:
+    
+    static_assert(!std::is_same<TDialogPolicy, TDialogCreateSession>());
+    using TBase = NActors::TActorBootstrapped<TSessionedActorCallback<TDialogPolicy>>;
+
+    void Handle(TEvRequestResult<TDialogCreateSession>::TPtr& ev) {
+        Ydb::Table::CreateSessionResponse currentFullReply = ev->Get()->GetResult();
+        Ydb::Table::CreateSessionResult session;
+        currentFullReply.operation().result().UnpackTo(&session);
+        const TString sessionId = session.session_id();
+        Y_VERIFY(sessionId);
+        InitSessionId(BaseRequest, sessionId);
+        TBase::Register(new TYDBControllerRequest<TDialogPolicy>(BaseRequest, UserToken, ExternalController, Config));
+    }
+protected:
+    typename TDialogPolicy::TRequest BaseRequest;
+    const TConfig Config;
+    const NACLib::TUserToken UserToken;
+    typename IExternalController::TPtr ExternalController;
+    virtual void InitSessionId(typename TDialogPolicy::TRequest& request, const TString& sessionId) {
+        request.set_session_id(sessionId);
+    }
+public:
+    STATEFN(StateMain) {
+        switch (ev->GetTypeRewrite()) {
+            hFunc(TEvRequestResult<TDialogCreateSession>, Handle);
+            hFunc(TEvRequestFailed, Handle);
+            hFunc(TEvRequestStart, Handle);
+            hFunc(TEvRequestResult<TDialogPolicy>, Handle);
+            default:
+                break;
+        }
+    }
+
+    TSessionedActorCallback(const typename TDialogPolicy::TRequest& request, const TConfig& config, const NACLib::TUserToken& uToken, typename IExternalController::TPtr externalController)
+        : BaseRequest(request)
+        , Config(config)
+        , UserToken(uToken)
+        , ExternalController(externalController)
+    {
+
+    }
+
+    void Handle(typename TEvRequestResult<TDialogPolicy>::TPtr& ev) {
+        ExternalController->OnRequestResult(ev->Get()->DetachResult());
+        TBase::PassAway();
+    }
+
+    void Handle(typename TEvRequestFailed::TPtr& ev) {
+        ExternalController->OnRequestFailed(ev->Get()->GetErrorMessage());
+    }
+
+    void Handle(typename TEvRequestStart::TPtr& /*ev*/) {
+        TBase::Register(new TYDBCallbackRequest<TDialogCreateSession>(TDialogCreateSession::TRequest(), UserToken, TBase::SelfId()));
+    }
+
+    void Bootstrap() {
+        TBase::Become(&TSessionedActorCallback::StateMain);
+        TBase::template Sender<TEvRequestStart>().SendTo(TBase::SelfId());
+    }
+};
+
 class IQueryOutput {
 public:
     using TPtr = std::shared_ptr<IQueryOutput>;
diff --git a/ydb/services/metadata/secret/checker_access.cpp b/ydb/services/metadata/secret/checker_access.cpp
index 1b522a6ea19..98e68f383fd 100644
--- a/ydb/services/metadata/secret/checker_access.cpp
+++ b/ydb/services/metadata/secret/checker_access.cpp
@@ -39,7 +39,7 @@ void TAccessPreparationActor::Bootstrap() {
 
 TAccessPreparationActor::TAccessPreparationActor(std::vector<TAccess>&& objects,
     NModifications::IAlterPreparationController<TAccess>::TPtr controller,
-    const NModifications::IOperationsManager::TModificationContext& context)
+    const NModifications::IOperationsManager::TInternalModificationContext& context)
     : Objects(std::move(objects))
     , Controller(controller)
     , Context(context)
diff --git a/ydb/services/metadata/secret/checker_access.h b/ydb/services/metadata/secret/checker_access.h
index 995d0d7d3b1..335bbba8e2a 100644
--- a/ydb/services/metadata/secret/checker_access.h
+++ b/ydb/services/metadata/secret/checker_access.h
@@ -12,7 +12,7 @@ class TAccessPreparationActor: public NActors::TActorBootstrapped<TAccessPrepara
 private:
     std::vector<TAccess> Objects;
     NModifications::IAlterPreparationController<TAccess>::TPtr Controller;
-    NModifications::IOperationsManager::TModificationContext Context;
+    NModifications::IOperationsManager::TInternalModificationContext Context;
     std::shared_ptr<NMetadata::NSecret::TSnapshot> Secrets;
     void StartChecker();
 protected:
@@ -29,7 +29,7 @@ public:
 
     TAccessPreparationActor(std::vector<TAccess>&& objects,
         NModifications::IAlterPreparationController<TAccess>::TPtr controller,
-        const NModifications::IOperationsManager::TModificationContext& context);
+        const NModifications::IOperationsManager::TInternalModificationContext& context);
 };
 
 }
diff --git a/ydb/services/metadata/secret/checker_secret.cpp b/ydb/services/metadata/secret/checker_secret.cpp
index e297a5cd6b6..74ac5e39483 100644
--- a/ydb/services/metadata/secret/checker_secret.cpp
+++ b/ydb/services/metadata/secret/checker_secret.cpp
@@ -40,7 +40,7 @@ void TSecretPreparationActor::Bootstrap() {
 
 TSecretPreparationActor::TSecretPreparationActor(std::vector<TSecret>&& objects,
     NModifications::IAlterPreparationController<TSecret>::TPtr controller,
-    const NModifications::IOperationsManager::TModificationContext& context)
+    const NModifications::IOperationsManager::TInternalModificationContext& context)
     : Objects(std::move(objects))
     , Controller(controller)
     , Context(context)
diff --git a/ydb/services/metadata/secret/checker_secret.h b/ydb/services/metadata/secret/checker_secret.h
index a2a6e6668a9..a6f72e2d6ef 100644
--- a/ydb/services/metadata/secret/checker_secret.h
+++ b/ydb/services/metadata/secret/checker_secret.h
@@ -12,7 +12,7 @@ class TSecretPreparationActor: public NActors::TActorBootstrapped<TSecretPrepara
 private:
     std::vector<TSecret> Objects;
     NModifications::IAlterPreparationController<TSecret>::TPtr Controller;
-    NModifications::IOperationsManager::TModificationContext Context;
+    NModifications::IOperationsManager::TInternalModificationContext Context;
     std::shared_ptr<NMetadata::NSecret::TSnapshot> Secrets;
     void StartChecker();
 protected:
@@ -29,7 +29,7 @@ public:
 
     TSecretPreparationActor(std::vector<TSecret>&& objects,
         NModifications::IAlterPreparationController<TSecret>::TPtr controller,
-        const NModifications::IOperationsManager::TModificationContext& context);
+        const NModifications::IOperationsManager::TInternalModificationContext& context);
 };
 
 }
diff --git a/ydb/services/metadata/secret/manager.cpp b/ydb/services/metadata/secret/manager.cpp
index a8f7494eff0..b4b776abd83 100644
--- a/ydb/services/metadata/secret/manager.cpp
+++ b/ydb/services/metadata/secret/manager.cpp
@@ -5,14 +5,15 @@
 
 namespace NKikimr::NMetadata::NSecret {
 
-void TAccessManager::DoPrepareObjectsBeforeModification(std::vector<TAccess>&& patchedObjects, NModifications::IAlterPreparationController<TAccess>::TPtr controller, const NModifications::IOperationsManager::TModificationContext& context) const {
+void TAccessManager::DoPrepareObjectsBeforeModification(std::vector<TAccess>&& patchedObjects, NModifications::IAlterPreparationController<TAccess>::TPtr controller,
+    const TInternalModificationContext& context) const {
     if (context.GetActivityType() == IOperationsManager::EActivityType::Alter) {
         controller->OnPreparationProblem("access object cannot be modified");
         return;
     }
-    if (!!context.GetUserToken()) {
+    if (!!context.GetExternalData().GetUserToken()) {
         for (auto&& i : patchedObjects) {
-            if (i.GetOwnerUserId() != context.GetUserToken()->GetUserSID()) {
+            if (i.GetOwnerUserId() != context.GetExternalData().GetUserToken()->GetUserSID()) {
                 controller->OnPreparationProblem("no permissions for modify secret access");
                 return;
             }
@@ -21,7 +22,8 @@ void TAccessManager::DoPrepareObjectsBeforeModification(std::vector<TAccess>&& p
     TActivationContext::Register(new TAccessPreparationActor(std::move(patchedObjects), controller, context));
 }
 
-NModifications::TOperationParsingResult TAccessManager::DoBuildPatchFromSettings(const NYql::TObjectSettingsImpl& settings, const NModifications::IOperationsManager::TModificationContext& context) const {
+NModifications::TOperationParsingResult TAccessManager::DoBuildPatchFromSettings(const NYql::TObjectSettingsImpl& settings,
+    TInternalModificationContext& context) const {
     NInternal::TTableRecord result;
     TStringBuf sb(settings.GetObjectId().data(), settings.GetObjectId().size());
     TStringBuf l;
@@ -31,7 +33,7 @@ NModifications::TOperationParsingResult TAccessManager::DoBuildPatchFromSettings
     }
     result.SetColumn(TAccess::TDecoder::SecretId, NInternal::TYDBValue::Utf8(l));
     result.SetColumn(TAccess::TDecoder::AccessSID, NInternal::TYDBValue::Utf8(r));
-    if (!context.GetUserToken()) {
+    if (!context.GetExternalData().GetUserToken()) {
         auto it = settings.GetFeatures().find(TAccess::TDecoder::OwnerUserId);
         if (it != settings.GetFeatures().end()) {
             result.SetColumn(TAccess::TDecoder::OwnerUserId, NInternal::TYDBValue::Utf8(it->second));
@@ -39,14 +41,15 @@ NModifications::TOperationParsingResult TAccessManager::DoBuildPatchFromSettings
             return "OwnerUserId not defined";
         }
     } else {
-        result.SetColumn(TAccess::TDecoder::OwnerUserId, NInternal::TYDBValue::Utf8(context.GetUserToken()->GetUserSID()));
+        result.SetColumn(TAccess::TDecoder::OwnerUserId, NInternal::TYDBValue::Utf8(context.GetExternalData().GetUserToken()->GetUserSID()));
     }
     return result;
 }
 
-NModifications::TOperationParsingResult TSecretManager::DoBuildPatchFromSettings(const NYql::TObjectSettingsImpl& settings, const NModifications::IOperationsManager::TModificationContext& context) const {
+NModifications::TOperationParsingResult TSecretManager::DoBuildPatchFromSettings(const NYql::TObjectSettingsImpl& settings,
+    TInternalModificationContext& context) const {
     NInternal::TTableRecord result;
-    if (!context.GetUserToken()) {
+    if (!context.GetExternalData().GetUserToken()) {
         auto it = settings.GetFeatures().find(TSecret::TDecoder::OwnerUserId);
         if (it != settings.GetFeatures().end()) {
             result.SetColumn(TSecret::TDecoder::OwnerUserId, NInternal::TYDBValue::Utf8(it->second));
@@ -54,7 +57,7 @@ NModifications::TOperationParsingResult TSecretManager::DoBuildPatchFromSettings
             return "OwnerUserId not defined";
         }
     } else {
-        result.SetColumn(TSecret::TDecoder::OwnerUserId, NInternal::TYDBValue::Utf8(context.GetUserToken()->GetUserSID()));
+        result.SetColumn(TSecret::TDecoder::OwnerUserId, NInternal::TYDBValue::Utf8(context.GetExternalData().GetUserToken()->GetUserSID()));
     }
     for (auto&& c : settings.GetObjectId()) {
         if (c >= '0' && c <= '9') {
@@ -83,10 +86,11 @@ NModifications::TOperationParsingResult TSecretManager::DoBuildPatchFromSettings
     return result;
 }
 
-void TSecretManager::DoPrepareObjectsBeforeModification(std::vector<TSecret>&& patchedObjects, NModifications::IAlterPreparationController<TSecret>::TPtr controller, const NModifications::IOperationsManager::TModificationContext& context) const {
-    if (!!context.GetUserToken()) {
+void TSecretManager::DoPrepareObjectsBeforeModification(std::vector<TSecret>&& patchedObjects, NModifications::IAlterPreparationController<TSecret>::TPtr controller,
+    const TInternalModificationContext& context) const {
+    if (!!context.GetExternalData().GetUserToken()) {
         for (auto&& i : patchedObjects) {
-            if (i.GetOwnerUserId() != context.GetUserToken()->GetUserSID()) {
+            if (i.GetOwnerUserId() != context.GetExternalData().GetUserToken()->GetUserSID()) {
                 controller->OnPreparationProblem("no permissions for modify secrets");
                 return;
             }
diff --git a/ydb/services/metadata/secret/manager.h b/ydb/services/metadata/secret/manager.h
index dd4817ae7e9..2ea535d901b 100644
--- a/ydb/services/metadata/secret/manager.h
+++ b/ydb/services/metadata/secret/manager.h
@@ -9,10 +9,11 @@ namespace NKikimr::NMetadata::NSecret {
 class TSecretManager: public NModifications::TGenericOperationsManager<TSecret> {
 protected:
     virtual void DoPrepareObjectsBeforeModification(std::vector<TSecret>&& patchedObjects,
-        NModifications::IAlterPreparationController<TSecret>::TPtr controller, const NModifications::IOperationsManager::TModificationContext& context) const override;
+        NModifications::IAlterPreparationController<TSecret>::TPtr controller,
+        const TInternalModificationContext& context) const override;
 
     virtual NModifications::TOperationParsingResult DoBuildPatchFromSettings(
-        const NYql::TObjectSettingsImpl& settings, const NModifications::IOperationsManager::TModificationContext& context) const override;
+        const NYql::TObjectSettingsImpl& settings, TInternalModificationContext& context) const override;
 
 public:
 };
@@ -21,10 +22,10 @@ class TAccessManager: public NModifications::TGenericOperationsManager<TAccess>
 protected:
     virtual void DoPrepareObjectsBeforeModification(std::vector<TAccess>&& patchedObjects,
         NModifications::IAlterPreparationController<TAccess>::TPtr controller,
-        const NModifications::IOperationsManager::TModificationContext& context) const override;
+        const TInternalModificationContext& context) const override;
 
     virtual NModifications::TOperationParsingResult DoBuildPatchFromSettings(const NYql::TObjectSettingsImpl& settings,
-        const NModifications::IOperationsManager::TModificationContext& context) const override;
+        TInternalModificationContext& context) const override;
 public:
 };